Questa pagina è stata tradotta dall'API Cloud Translation.

Attendi gli eventi utilizzando callback e trigger Eventarc

Il flusso di lavoro potrebbe dover attendere un processo esterno. Puoi utilizzare la modalità callback HTTP per attendere a un altro servizio per fare una richiesta a un endpoint di callback; la richiesta riprende l'esecuzione del flusso di lavoro. Puoi anche in attesa di usare il sondaggio.

Anziché utilizzare i sondaggi, questo tutorial mostra come attendere gli eventi o i messaggi Pub/Sub che utilizzano i callback HTTP e Eventarc trigger. Sebbene sia possibile attivare un flusso di lavoro con eventi o messaggi Pub/Sub, potresti voler interrompere l'esecuzione per attendere un altro evento prima continua. Ad esempio, un evento attiva un flusso di lavoro per avviare un processo, il flusso di lavoro deve attendere un altro evento che segnali che il processo completato. Puoi implementare questa soluzione facendo in modo che un flusso di lavoro richiami un altro nel tuo flusso di lavoro.

Obiettivi

In questo tutorial, si verifica quanto segue:

Viene eseguito il deployment ed eseguito un flusso di lavoro principale che deve attendere gli eventi. Poiché deve attendere che gli eventi si verifichino, memorizza i dettagli del callback in un Firestore in modo che il flusso di lavoro secondario possa recuperare i dettagli. Il flusso di lavoro principale attende quindi le chiamate HTTP.
Gli eventi attivano un flusso di lavoro secondario che recupera i i dettagli del callback dal database Firestore quando gli eventi vengono generati. Il flusso di lavoro secondario richiama quindi il flusso di lavoro principale, ne riprende l'esecuzione.

Ecco una panoramica dell'intera procedura:

Flusso di lavoro principale:

Un flusso di lavoro callback-event-sample crea endpoint di callback per due eventi Origini: un argomento Pub/Sub e un bucket Cloud Storage.
Questo flusso di lavoro archivia entrambi gli endpoint di callback in un file documento.
Questo flusso di lavoro interrompe l'esecuzione e attende l'arrivo delle richieste HTTP gli endpoint di callback.

Eventi:

Si verificano eventi: un messaggio viene pubblicato in un argomento Pub/Sub e il file viene caricato in un bucket Cloud Storage.

Flusso di lavoro secondario:

Eventarc instrada gli eventi flusso di lavoro callback-event-listener e ne attiva l'esecuzione.
Questo flusso di lavoro recupera gli URL dell'endpoint di callback appropriati dal Documento Firestore.
Questo flusso di lavoro esegue i callback negli endpoint appropriati nel un flusso di lavoro di esempio.

Flusso di lavoro principale:

Il flusso di lavoro callback-event-sample riceve gli eventi alla di callback di questi endpoint e ne riprende l'esecuzione.
Questo flusso di lavoro elimina gli URL di callback da Firestore documento e ne completa l'esecuzione.

Costi

In questo documento vengono utilizzati i seguenti componenti fatturabili di Google Cloud:

Per generare una stima dei costi basata sull'utilizzo previsto, utilizza il Calcolatore prezzi. I nuovi utenti di Google Cloud potrebbero essere idonei per una prova gratuita.

Prima di iniziare

Puoi eseguire i comandi seguenti nella console Google Cloud o utilizzando Google Cloud CLI nel terminale o in Cloud Shell.

I vincoli di sicurezza definiti dalla tua organizzazione potrebbero impedirti di completare i passaggi seguenti. Per informazioni sulla risoluzione dei problemi, vedi Sviluppare applicazioni in un ambiente Google Cloud vincolato.

Console

Nella pagina del selettore progetti della console Google Cloud, seleziona oppure creare un progetto Google Cloud.

Nota: se non prevedi di conservare le risorse create in questo crea un progetto invece di selezionarne uno esistente. Dopo il giorno Per completare questi passaggi, puoi eliminare il progetto, rimuovendo tutte le risorse associati al progetto.

Vai al selettore progetti
Verifica che la fatturazione sia attivata per il tuo progetto Google Cloud. Scopri come verifica se la fatturazione è abilitata su un progetto.
Abilita App Engine, Eventarc, Firestore le API Pub/Sub e Workflows.

Abilita le API
Crea un account di servizio per il flusso di lavoro da utilizzare per l'autenticazione con altri servizi Google Cloud e assegnagli i ruoli appropriati:
1. Nella console Google Cloud, vai ad Account di servizio. .
  
  Vai a Service account
2. Per andare alla pagina Crea account di servizio, seleziona il tuo progetto.
3. Inserisci un nome nel campo Nome account di servizio. Console Google Cloud compila il campo ID account di servizio in base a questo nome.
  
  Nel campo Descrizione account di servizio, inserisci una descrizione. Ad esempio, Service account for tutorial.
4. Fai clic su Crea e continua.
5. Nell'elenco Seleziona un ruolo, filtra i seguenti ruoli da concedere all'account di servizio gestito dall'utente che hai creato nel passaggio precedente:
  - Utente Cloud Datastore: per accedere a Firestore in modalità Datastore (Datastore) e i dati di Google Cloud.
  - Ricevitore eventi Eventarc: per ricevere eventi dai fornitori di eventi.
  - Writer log: per scrivere i log.
  - Invoker dei flussi di lavoro: per eseguire flussi di lavoro e gestire eseguite.
  Per altri ruoli, fai clic su Aggiungi un altro ruolo e aggiungi ogni altro ruolo.
  
  Nota: il campo Ruolo influisce sulle risorse del tuo account di servizio a cui possono accedere nel tuo progetto. Puoi revocare questi ruoli o concedere altri ruoli in seguito. In ambienti di produzione, non concedere Ruoli di proprietario, editor o visualizzatore. Concedi invece ruolo predefinito o ruolo personalizzato che soddisfa le e alle esigenze aziendali.
6. Fai clic su Continua.
7. Per completare la creazione dell'account, fai clic su Fine.
Per creare un trigger Eventarc che instrada gli eventi da Cloud Storage, concedi il ruolo Publisher Pub/Sub all'agente di servizio Cloud Storage. In genere, si tratta di service-PROJECT_NUMBER@gs-project-accounts.iam.gserviceaccount.com. Puoi recuperare l'indirizzo email dell'agente di servizio Cloud Storage.
1. Nella console Google Cloud, vai alla pagina IAM.
  
  Vai a IAM
2. Nella riga relativa all'agente di servizio Cloud Storage, fai clic su Modifica entità. (Se che l'agente di servizio non è presente nell'elenco, vai al passaggio successivo.) Si apre il riquadro Modifica accesso.
  1. Fai clic su Aggiungi un altro ruolo e quindi cerca il ruolo Publisher Pub/Sub.
  2. Seleziona il ruolo.
  3. Fai clic su Salva.
3. Se l'agente di servizio non è nell'elenco, fai clic su Concedi l'accesso. Si apre il riquadro Concedi l'accesso.
  1. Nel campo Nuove entità, inserisci l'indirizzo email per dell'agente di servizio di servizio di Google Cloud.
  2. Nell'elenco Seleziona un ruolo, cerca Publisher Pub/Sub. ruolo.
  3. Seleziona il ruolo.
  4. Fai clic su Salva.

gcloud

In the Google Cloud console, activate Cloud Shell.

Activate Cloud Shell

At the bottom of the Google Cloud console, a Cloud Shell session starts and displays a command-line prompt. Cloud Shell is a shell environment with the Google Cloud CLI already installed and with values already set for your current project. It can take a few seconds for the session to initialize.
Verifica che la fatturazione sia attivata per il tuo progetto Google Cloud. Scopri come verifica se la fatturazione è abilitata su un progetto.

Abilita App Engine, Eventarc, Firestore, Pub/Sub e Workflows su quelle di livello inferiore.

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

Crea un account di servizio per il flusso di lavoro da utilizzare per l'autenticazione con gli altri servizi Google Cloud e assegnargli i ruoli appropriati.
1. Crea l'account di servizio:
```
gcloud iam service-accounts create SERVICE_ACCOUNT_NAME
```
  Sostituisci SERVICE_ACCOUNT_NAME con il nome di l'account di servizio.
2. Concedi i ruoli all'account di servizio gestito dall'utente che hai creato in passaggio precedente. Esegui questo comando una volta per ciascuno dei seguenti Ruoli IAM:
  - roles/datastore.user: per accedere a Firestore in modalità Datastore (Datastore) e i dati di Google Cloud.
  - roles/eventarc.eventReceiver: per ricevere eventi dall'evento di Google Cloud.
  - roles/logging.logWriter: per scrivere i log.
  - roles/workflows.invoker: per eseguire flussi di lavoro e gestire eseguite.
```
gcloud projects add-iam-policy-binding PROJECT_ID \
    --member=serviceAccount:SERVICE_ACCOUNT_NAME@PROJECT_ID.iam.gserviceaccount.com \
    --role=ROLE
```
  Sostituisci quanto segue:
  - PROJECT_ID: il ID progetto in cui hai creato l'account di servizio
  - ROLE: il ruolo da concedere
  Nota: il flag --role influisce sulle risorse sul tuo account di servizio a cui possono accedere nel tuo progetto. Puoi revocare questi ruoli o concedere altri ruoli in seguito. In ambienti di produzione, non concedere Ruoli di proprietario, editor o visualizzatore. Concedi invece ruolo predefinito o ruolo personalizzato che soddisfa le e alle esigenze aziendali.
Per creare un trigger Eventarc che instrada gli eventi da Cloud Storage, concedi il ruolo Publisher Pub/Sub alla Agente di servizio Cloud Storage. In genere, si tratta di service-PROJECT_NUMBER@gs-project-accounts.iam.gserviceaccount.com. Utilizza le funzionalità di gcloud storage service-agent per recuperare l'agente di servizio Cloud Storage.
```
SERVICE_ACCOUNT_STORAGE="$(gcloud storage service-agent --project=PROJECT_ID)"

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

Crea un database Firestore

Firestore archivia i tuoi dati in documenti che contengono campi mappatura dei valori. Questi documenti sono archiviati in raccolte, di container per i tuoi documenti, che puoi usare per organizzare i dati query. Scopri di più su Firestore.

Tieni presente che ogni progetto Google Cloud è limitato a un file Firestore per configurare un database. Completa i seguenti passaggi se devi creare un nuovo database.

Console

Nella console Google Cloud, vai a Firestore Pagina Inizia.

Vai alla pagina Inizia
Fai clic su Seleziona modalità nativa.

Per indicazioni sulla selezione di una modalità di database e per una caratteristica per caratteristica confronto, vedi tra la modalità Native e la modalità Datastore.
Nell'elenco Seleziona una località, seleziona nam5 (Stati Uniti).

La località si applica sia al database Firestore che l'applicazione App Engine nel tuo progetto Google Cloud. Dopo aver creato il database, non puoi modificare la località.
Fai clic su Crea database.

gcloud

Per creare un database Firestore, devi prima creare un'istanza nell'applicazione App Engine ed eseguirai gcloud firestore databases create :

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

Puoi ignorare l'avviso us-central is not a valid Firestore location. App Engine e Firestore supportano le stesse località, ma la regione us-central di App Engine (Iowa) viene mappata Firestore nam5 (Stati Uniti) in più regioni.

crea un argomento Pub/Sub

Questo tutorial utilizza Pub/Sub come origine evento. Crea un all'argomento Pub/Sub, in modo da potervi pubblicare un messaggio. Scopri di più sulla creazione e sulla gestione degli argomenti.

Console

Nella console Google Cloud, vai al Pub/Sub Pagina Argomenti.

Vai ad Argomenti
Fai clic su Crea argomento.
Nel campo ID argomento, inserisci topic-callback.
Accetta gli altri valori predefiniti.
Fai clic su Crea argomento.

gcloud

Per creare un argomento, esegui gcloud pubsub topics create :

gcloud pubsub topics create topic-callback

Crea un bucket Cloud Storage

Questo tutorial utilizza Cloud Storage come origine evento. Crea un nel bucket Cloud Storage, per caricare un file al suo interno. Scopri di più sulla creazione di bucket di archiviazione.

Console

Nella console Google Cloud, vai a Cloud Storage la pagina Bucket.

Vai a Cloud Storage
Fai clic su Crea.
Per il Nome del bucket, inserisci PROJECT_ID-bucket-callback.

L'ID progetto viene utilizzato nel flusso di lavoro callback-event-sample per identificare il bucket.
Fai clic su Continua.
In Tipo di località, seleziona Regione, quindi us-central1 (Iowa)
Accetta gli altri valori predefiniti.
Fai clic su Crea.

gcloud

Per creare un bucket, esegui gcloud storage buckets create :

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

L'ID progetto viene utilizzato nel flusso di lavoro callback-event-sample per identificare il bucket.

Dopo aver creato le origini eventi, puoi eseguire il deployment del flusso di lavoro del destinatario di eventi.

Esegui il deployment di un flusso di lavoro che rimane in ascolto degli eventi

Il flusso di lavoro callback-event-listener viene attivato alla pubblicazione di un messaggio in un argomento Pub/Sub o quando un file viene caricato di sincronizzare la directory di una VM con un bucket. Il flusso di lavoro riceve l'evento e recupera il callback appropriato dettagli dal database Firestore, quindi invia una richiesta HTTP richiesta all'endpoint di callback.

Console

Nella console Google Cloud, vai a Workflows pagina:

Vai a Flussi di lavoro
Fai clic su Crea.
Inserisci un nome per il nuovo flusso di lavoro: callback-event-listener.
Nell'elenco Regione, seleziona us-central1.
Seleziona l'Account di servizio creato in precedenza.
Fai clic su Avanti.

Nell'editor del flusso di lavoro, inserisci la seguente definizione per il tuo flusso di lavoro:

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}

Fai clic su Esegui il deployment.

gcloud

Crea un file di codice sorgente per il tuo flusso di lavoro:
```
touch callback-event-listener.yaml
```

In un editor di testo, copia il seguente flusso di lavoro nel file del codice sorgente:

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}

Esegui il deployment del flusso di lavoro inserendo il comando seguente:

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

Sostituisci SERVICE_ACCOUNT_NAME con il nome di l'account di servizio che hai creato in precedenza.

Esegui il deployment di un flusso di lavoro in attesa di eventi

Il flusso di lavoro callback-event-sample archivia i dettagli del callback in un il database Firestore, ne interrompe l'esecuzione e attende a determinati eventi.

Console

Nella console Google Cloud, vai a Workflows pagina:

Vai a Flussi di lavoro
Fai clic su Crea.
Inserisci un nome per il nuovo flusso di lavoro: callback-event-sample.
Nell'elenco Regione, seleziona us-central1.
Seleziona l'Account di servizio creato in precedenza.
Fai clic su Avanti.

Nell'editor del flusso di lavoro, inserisci la seguente definizione per il tuo flusso di lavoro:

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}

Fai clic su Esegui il deployment.

gcloud

Crea un file di codice sorgente per il tuo flusso di lavoro:
```
touch callback-event-sample.yaml
```

In un editor di testo, copia il seguente flusso di lavoro nel file del codice sorgente:

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}

Esegui il deployment del flusso di lavoro inserendo il comando seguente:

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

Sostituisci SERVICE_ACCOUNT_NAME con il nome di l'account di servizio che hai creato in precedenza.

crea un trigger Eventarc per il routing degli eventi Pub/Sub

Un trigger Eventarc ti consente di instradare gli eventi specificando filtri per l'attivatore, tra cui l'origine evento e il flusso di lavoro di destinazione. Crea un trigger Eventarc per eseguire callback-event-listener come risultato della pubblicazione di un messaggio in un Pub/Sub. Scopri di più sull'attivazione di un flusso di lavoro.

Console

Nella console Google Cloud, vai alla pagina Eventarc.

Vai a Eventarc
Fai clic su Crea trigger.
Digita un Nome trigger.

Ad esempio, trigger-pubsub-events-listener.
Nell'elenco Provider di eventi, seleziona Cloud Pub/Sub.
Nell'elenco Evento, in Personalizzato, seleziona google.cloud.pubsub.topic.v1.messagePublished.
Nell'elenco Seleziona un argomento Cloud Pub/Sub, seleziona l'argomento creato in precedenza.
Nell'elenco Regione, seleziona us-central1 (Iowa).
Se richiesto, concedi il ruolo iam.serviceAccountTokenCreator a l'account di servizio Pub/Sub.
Seleziona l'Account di servizio creato in precedenza.
Nell'elenco Destinazione evento, seleziona Flussi di lavoro.
Nell'elenco Seleziona un flusso di lavoro, scegli callback-event-listener nel tuo flusso di lavoro.
Fai clic su Crea.

gcloud

Per creare un trigger, esegui il 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

Gli eventi vengono trasformati e passati all'esecuzione del flusso di lavoro come argomenti di runtime. Tieni presente che l'attivazione del nuovo trigger può richiedere fino a 2 minuti.

Crea un trigger Eventarc per il routing degli eventi di Cloud Storage

Un trigger Eventarc ti consente di instradare gli eventi specificando filtri per l'attivatore, tra cui l'origine evento e il flusso di lavoro di destinazione. Crea un trigger Eventarc per eseguire callback-event-listener come risultato del caricamento di un file in un nel bucket Cloud Storage. Scopri di più sull'attivazione di un flusso di lavoro.

Console

Nella console Google Cloud, vai a Eventarc. .

Vai a Eventarc
Fai clic su Crea trigger.
Digita un Nome trigger.

Ad esempio, trigger-storage-events-listener.
Nell'elenco Provider di eventi, seleziona Cloud Storage.
Nell'elenco Evento, in Diretto, seleziona google.cloud.storage.object.v1.finalized
Nell'elenco Bucket, cerca il bucket creato in precedenza. e selezionalo.
Nell'elenco Regione, in base al tuo bucket Cloud Storage, accetta il valore predefinito di us-central1 (Iowa)
Se richiesto, concedi il ruolo iam.serviceAccountTokenCreator a l'account di servizio Pub/Sub.
Seleziona l'Account di servizio creato in precedenza.
Nell'elenco Destinazione evento, seleziona Flussi di lavoro.
Nell'elenco Seleziona un flusso di lavoro, scegli callback-event-listener nel tuo flusso di lavoro.
Fai clic su Crea.

gcloud

Per creare un trigger, esegui il 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

Gli eventi vengono trasformati e passati all'esecuzione del flusso di lavoro come argomenti di runtime. Tieni presente che l'attivazione del nuovo trigger può richiedere fino a 2 minuti.

Esegui il flusso di lavoro principale

L'esecuzione di un flusso di lavoro esegue la definizione attuale del flusso di lavoro associata nel tuo flusso di lavoro. Esegui il flusso di lavoro callback-event-sample. Questo è il principale flusso di lavoro e attende il verificarsi di eventi specifici, per poi riprenderne l'esecuzione quando il flusso di lavoro secondario effettua le richieste di callback appropriate.

Console

Nella console Google Cloud, vai alla pagina Flussi di lavoro.

Vai a Flussi di lavoro
Nella pagina Flussi di lavoro, fai clic sul pulsante callback-event-sample per andare alla relativa pagina dei dettagli.
Nella pagina Dettagli del flusso di lavoro, fai clic su Esegui.
Fai di nuovo clic su Esegui.

Viene avviata l'esecuzione del flusso di lavoro. Durante l'esecuzione, dovresti vedere uno stato di esecuzione di Running e una voce di log simile seguenti: Started waiting 1hr for an event from source topic-callback.

gcloud

Per eseguire un flusso di lavoro, esegui Comando gcloud workflows run:

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

Viene avviata l'esecuzione del flusso di lavoro. Durante l'esecuzione, dovresti vedere uno stato di esecuzione simile al seguente:

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

Genera eventi e controlla lo stato di esecuzione

Puoi confermare che i risultati siano quelli previsti generando eventi, visualizzando voci di log e controllare lo stato di esecuzione del flusso di lavoro.

Pubblica un messaggio

Pubblica un messaggio nell'argomento Pub/Sub che hai precedentemente è stato creato.

Console

Nella console Google Cloud, vai al Pub/Sub Pagina Argomenti.

Vai ad Argomenti
Fai clic su topic-callback.
Fai clic sulla scheda Messaggi.
Fai clic su Pubblica messaggio.
Nel campo Corpo del messaggio, inserisci Hello World.
Fai clic su Pubblica.

gcloud

Per pubblicare un messaggio, utilizza gcloud pubsub topics publish :

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

Carica un oggetto

Carica un file nel bucket Cloud Storage che hai creato in precedenza.

Console

Nella console Google Cloud, vai alla pagina Bucket di Cloud Storage.

Vai a Bucket
Fai clic sul nome del bucket che hai creato in precedenza.
Nella scheda Oggetti, esegui una delle seguenti operazioni:
- Trascina il file desiderato dal desktop o da Gestione file al riquadro principale della console Google Cloud.
- Fai clic su Carica file, seleziona il file che vuoi caricare e e poi fai clic su Apri.

gcloud

Per caricare un file, esegui gcloud storage cp :

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

Sostituisci OBJECT_LOCATION con il percorso locale del tuo . Ad esempio, random.txt.

Visualizza le voci di log e lo stato di esecuzione

Verifica che il flusso di lavoro callback-event-sample sia stato completato correttamente.

Console

Nella console Google Cloud, vai alla pagina Flussi di lavoro.

Vai a Flussi di lavoro
Nella pagina Flussi di lavoro, fai clic sul pulsante callback-event-sample per andare alla relativa pagina dei dettagli.
Nella pagina Dettagli flusso di lavoro, per recuperare i dettagli di un particolare esecuzione, fare clic sull'ID esecuzione appropriato.

Lo stato di esecuzione deve essere Riuscito e, nel riquadro Output, dovresti vedere i messaggi Pub/Sub ricevuti eventi di Cloud Storage.

gcloud

Filtra le voci di log e restituisci l'output in formato JSON:

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

Cerca voci di log simili a queste:

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

Controlla lo stato dell'ultimo tentativo di esecuzione:

gcloud workflows executions wait-last

Il risultato dovrebbe essere simile al seguente:

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

Esegui la pulizia

Se hai creato un nuovo progetto per questo tutorial, elimina il progetto. Se hai utilizzato un progetto esistente e vuoi mantenerlo senza l'aggiunta delle modifiche In questo tutorial, elimina le risorse create per il tutorial.

Elimina il progetto

Il modo più semplice per eliminare la fatturazione creato per il tutorial.

Per eliminare il progetto:

Attenzione: l'eliminazione di un progetto ha i seguenti effetti:

L'intero contenuto del progetto viene eliminato. Se hai utilizzato un progetto esistente per le attività in questo documento, quando lo elimini elimini anche qualsiasi altro lavoro svolto nel progetto.
Gli ID progetto personalizzati non sono più disponibili. Quando hai creato questo progetto, potresti aver creato un ID progetto personalizzato che vuoi utilizzare in futuro. Per conservare gli URL che utilizzano l'ID progetto, ad esempio un URL appspot.com, elimina le risorse selezionate all'interno del progetto anziché eliminare l'intero progetto.

Se intendi esplorare più architetture, tutorial o guide rapide, puoi riutilizzare i progetti ed evitare così di superare i limiti di quota.

Nella console Google Cloud, vai alla pagina Gestisci risorse.
Vai a Gestisci risorse
Nell'elenco dei progetti, seleziona il progetto che vuoi eliminare, quindi fai clic su Elimina.
Nella finestra di dialogo, digita l'ID del progetto e fai clic su Chiudi per eliminare il progetto.

Elimina le risorse create in questo tutorial

Passaggi successivi

Prova il tutorial Creare un flusso di lavoro human-in-the-loop utilizzando i callback.