Integrare i moduli di backend con il sistema

I moduli di backend forniscono un'infrastruttura per elaborare grandi volumi di messaggi correlati alle funzionalità e interagire con la UI del desktop dell'agente. Questo tutorial ti guida nella procedura di integrazione dei moduli di backend con il sistema di agenti.

Per ulteriori informazioni sui concetti e sulla struttura dei moduli di backend, consulta la documentazione relativa alle nozioni di base sui moduli di backend.

Prerequisiti

  1. Se non l'hai configurata, installa Google Cloud CLI.
  2. Crea un argomento Cloud Pub/Sub per ogni tipo di notifica degli eventi che ti serve da Dialogflow. Prendi nota dell'ID argomento e del nome dell'argomento per il deployment backend successivo.
  3. Configura il profilo conversazione utilizzando la console Agent Assist con gli argomenti Pub/Sub.

Deployment automatico

Il deployment può essere automatizzato da uno Google Cloud script di automazione o da Terraform.

Script di automazione

Per maggiori dettagli, puoi consultare ./deploy.sh.

Applica le modifiche di Terraform

Puoi automatizzare il deployment con uno script di automazione gcloud CLI o Terraform. Prima di applicare le modifiche di Terraform, completa i seguenti passaggi.

  1. Concedi i seguenti ruoli IAM al tuo account:
    • Project IAM Admin (roles/resourcemanager.projectIamAdmin)
    • Service Usage Admin (roles/serviceusage.serviceUsageAdmin)
    • Service Account Admin (roles/iam.serviceAccountAdmin)
    • Service Account User (roles/iam.serviceAccountUser)
    • Pub/Sub Admin (roles/pubsub.admin)
    • Secret Manager Admin (roles/secretmanager.admin)
    • Cloud Build Editor (roles/cloudbuild.builds.editor)
    • Artifact Registry Administrator (roles/artifactregistry.admin)
    • Storage Admin (roles/storage.admin)
    • Cloud Run Admin (roles/run.admin)
    • Cloud Memorystore Redis Admin (roles/redis.admin)
    • Serverless VPC Access Admin (roles/vpcaccess.admin)
  2. Crea immagini per UI Connector e per l'intercettore Cloud Pub/Sub e annota il nome dell'immagine.
    • Per UI Connector, esegui questo comando nella cartella ./ui-connector. 
      $ gcloud builds submit --tag gcr.io/$GCP_PROJECT_ID/aa-integration-backend/ui-connector
    • Per Cloud Pub/Sub Interceptor, esegui il comando seguente nella cartella ./cloud-pubsub-interceptor. 
      $ gcloud builds submit --tag gcr.io/$GCP_PROJECT_ID/aa-integration-backend/cloud-pubsub-interceptor
  3. Crea un bucket Cloud Storage per archiviare lo stato di Terraform e aggiorna il valore del bucket di backend in /terraform/backend.tf utilizzando il seguente comando. 
    GCP_PROJECT_ID=$(gcloud config get-value project)
# Create the Cloud storage bucket
gcloud storage buckets create gs://${GCP_PROJECT_ID}-tfstate
# Enable Object Versioning to keep the history of your deployments
gcloud storage buckets update gs://${GCP_PROJECT_ID}-tfstate --versioning
  4. Esporta il valore delle variabili Terraform richieste gcp_project_id, ui_connector_docker_image e cloud_pubsub_interceptor_docker_image. Esempio: export TF_VAR_gcp_project_id='you-gcp-project-id'. In alternativa, puoi compilare i valori direttamente in /terraform/variables.tf.
  5. Personalizza il metodo di autenticazione modificando il metodo auth.check_auth() all'indirizzo /ui-connector/auth.py.

Se vuoi automatizzare questi passaggi utilizzando Cloud Build, segui queste istruzioni e utilizza il file di configurazione di build ./terraform_cloudbuild.yaml. Per consentire a Cloud Build di eseguire il deployment dei servizi, devi concedere all'account di servizio Cloud Build i ruoli IAM elencati nel passaggio 1.

Deployment manuale

I passaggi seguenti spiegano come eseguire il deployment manuale dei moduli di backend.

Imposta le variabili di ambiente

Per semplificare i comandi per il deployment, ti consigliamo di impostare le seguenti variabili di ambiente utili nella shell. Puoi impostare le variabili utilizzando il seguente comando di esempio:

$ export GCP_PROJECT_ID='aa-integration-service'

Imposta le seguenti variabili di ambiente:

  • GCP_PROJECT_ID: l'ID progetto del tuo progetto piattaforma Cloud che ospita le risorse correlate. Esempio: my-project.
  • SERVICE_REGION: la località o la regione dei tuoi servizi e delle risorse Google Cloud correlate. Risorse della piattaforma. Esempio: us-central1.

Configurare un account amministrativo

Ti consigliamo di utilizzare account Google Cloud separati per l'amministrazione dei servizi e l'identità di runtime. L'amministrazione dei servizi viene eseguita principalmente da persone con account Google, mentre l'identità di runtime concede ai servizi Cloud Run le autorizzazioni utilizzando account di servizio per consentire l'accesso alle risorse necessarie.

Preparare l'account amministrativo umano

Se prevedi di utilizzare un account che dispone già delle autorizzazioni Editor o Proprietario nel tuo progetto, puoi passare alla sezione successiva.

Per gestire l'infrastruttura di backend, crea un account amministratore e concedigli i seguenti ruoli IAM (Identity and Access Management). Le loro autorizzazioni sono tutte incluse nei ruoli di base Editor e Proprietario.

  • roles/secretmanager.admin (Amministratore Secret Manager): gestisci i secret archiviati in Secret Manager per la generazione e la verifica di JWT.
  • roles/run.admin (Amministratore di Cloud Run): esegui il deployment e gestisci i servizi Cloud Run.
  • roles/iam.serviceAccountUser (Utente service account): concedi le autorizzazioni iam.serviceAccounts.actAs ai service account di runtime Cloud Run.
  • roles/cloudbuild.builds.editor (Editor Cloud Build): crea immagini Docker per i servizi di integrazione utilizzando Cloud Build.
  • Amministratore Artifact Registry: archivia e gestisci le immagini Docker create per i servizi di integrazione.
  • roles/pubsub.editor (Editor Cloud Pub/Sub): crea e gestisci argomenti e sottoscrizioni Cloud Pub/Sub.
  • roles/redis.admin (Redis Admin): crea e gestisci le risorse di Memorystore for Redis.

Per concedere ruoli IAM a un account utente, utilizza il comando add-iam-policy-binding Google Cloud CLI. Di seguito è riportato un comando di esempio:

$ gcloud projects add-iam-policy-binding $GCP_PROJECT_ID \
 --member='user:test-user@gmail.com' \
 --role='roles/pubsub.editor'

Imposta l'account amministrativo umano in gcloud

Sostituisci $ADMIN_ACCOUNT con l'account amministratore che vuoi utilizzare (ad esempio: myaccount@gmail.com) nel seguente esempio:

$ gcloud config set account $ADMIN_ACCOUNT

Configurare i service account

Per impostazione predefinita, i servizi o i job Cloud Run vengono eseguiti come account di servizio predefinito di Compute Engine. Anziché lasciare il valore predefinito, ti consigliamo di assegnare a ogni servizio Cloud Run un'identità dedicata assegnandogli un account di servizio gestito dall'utente con il set minimo di autorizzazioni richieste. Se prevedi di mantenere l'account di servizio predefinito, puoi passare direttamente a impostare le variabili di ambiente.

Crea due service account per ogni runtime Cloud Run

  1. Per creare i service account, sostituisci il valore di $CONNECTOR_SERVICE_ACCOUNT_ID e $INTERCEPTOR_SERVICE_ACCOUNT_ID, se necessario, ed esegui i seguenti comandi:

    $ export CONNECTOR_SERVICE_ACCOUNT_ID='aa-ui-connector' && gcloud iam service-accounts create $CONNECTOR_SERVICE_ACCOUNT_ID \
--description='Agent Assist integration - UI connector service account' \
--display-name='Agent Assist integration - UI connector'
$ export INTERCEPTOR_SERVICE_ACCOUNT_ID='aa-pubsub-interceptor' && gcloud iam service-accounts create $INTERCEPTOR_SERVICE_ACCOUNT_ID \
--description='Agent Assist integration - Pubsub interceptor service account' \
--display-name='Agent Assist integration - Pubsub interceptor'

  2. Utilizza il seguente comando di esempio per assegnare i seguenti ruoli ai service account del connettore UI e del connettore Cloud Pub/Sub:

    $ gcloud projects add-iam-policy-binding $GCP_PROJECT_ID \
--member='serviceAccount:$CONNECTOR_SERVICE_ACCOUNT_ID@$GCP_PROJECT_ID.iam.gserviceaccount.com' \
--role='roles/pubsub.editor'

Concedi i seguenti ruoli IAM al account di servizio del connettore UI:

  • roles/redis.editor
  • roles/vpcaccess.user
  • roles/compute.viewer
  • roles/secretmanager.secretAccessor
  • roles/dialogflow.agentAssistClient

Concedi i seguenti ruoli al account di servizio del connettore Cloud Pub/Sub:

  • roles/redis.editor
  • roles/vpcaccess.user
  • roles/compute.viewer

Imposta le variabili di ambiente

Imposta i valori delle seguenti variabili di ambiente in modo che corrispondano ai service account che hai appena creato o al service account Compute Engine predefinito nel tuo progetto.

  1. CONNECTOR_SERVICE_ACCOUNT: Il account di servizio per il runtime del connettore UI. Esempio: aa-ui-connector@my-project-id.iam.gserviceaccount.com.
  2. INTERCEPTOR_SERVICE_ACCOUNT: Il account di servizio per il runtime dell'intercettore Cloud Pub/Sub. Esempio: aa-pubsub-interceptor@my-project-id.iam.gserviceaccount.com.

Personalizzare il metodo di autenticazione utente

Il repository di codice supporta sia gli utenti di backend sia gli utenti del modulo frontend per Genesys Cloud e Twilio.

  1. All'interno del repository di codice, apri il file ui_connector/auth.py.

  2. Specifica il provider di identità supportato impostando la variabile di ambiente AUTH_OPTION o implementa il tuo metodo di autenticazione con auth.check_auth.

    Per impostazione predefinita, AUTH_OPTION è vuoto e nessun utente è autorizzato a registrare JWT con il servizio UI Connector. Valori supportati:

    • Salesforce: verifica il token di autenticazione utilizzando Salesforce OpenID Connect. Variabile di ambiente obbligatoria: SALESFORCE_ORGANIZATION_ID.
    • SalesforceLWC: verifica un token di autenticazione delle credenziali client OAuth di Salesforce utilizzando l'endpoint REST oauth2/userinfo. Variabili di ambiente richieste: SALESFORCE_ORGANIZATION_ID, SALESFORCE_DOMAIN.
    • GenesysCloud: verifica il token di autenticazione utilizzando l'API Users di Genesys SDK.
    • Twilio: verifica il token di autenticazione per Twilio. Variabile di ambiente obbligatoria: TWILIO_FLEX_ENVIRONMENT.
    • Skip: salta la verifica del token di autenticazione. Non deve essere utilizzato in produzione.

    Esempio: 

    $ export AUTH_OPTION='Salesforce'

    Ogni tipo di token potrebbe avere un mezzo di convalida diverso. Sei tu a decidere come convalidare il token. Senza modifiche, auth.check_auth restituisce false per ogni richiesta.

Per limitare le origini che possono accedere al tuo servizio, modifica il valore della variabile config.CORS_ALLOWED_ORIGINS. Il valore predefinito * consentirà a qualsiasi origine di visitare il tuo servizio.

Genera e archivia una chiave segreta JWT

Affinché il servizio del connettore UI invii token di autenticazione sicuri al client, deve criptarli utilizzando una chiave segreta JWT. Il valore della chiave può essere una stringa arbitraria, anche se deve essere univoca e difficile da indovinare.

Questa chiave segreta verrà archiviata in Secret Manager.

Imposta variabile di ambiente

  • JWT_SECRET_NAME: il nome della chiave segreta in Secret Manager. Può essere un nome arbitrario. Valore consigliato: aa-integration-jwt-secret.

Genera la chiave

Ti consigliamo di generare un hash casuale come chiave segreta JWT in modo che non possa essere indovinato dagli autori degli attacchi. Per farlo, puoi utilizzare python secrets per generare numeri casuali sicuri.

# generate_secret_key.py
import secrets
jwt_secret_key = secrets.token_bytes(16)
print(jwt_secret_key) # Output example: b'L\x9b\xd6i4\xc3\x1d\x95\xe3\xf78z\xdda\x97\xec'

Archivia la chiave in Secret Manager

Nel seguente comando di esempio, sostituisci my_key con la chiave segreta che intendi utilizzare.

$ python generate_secret_key.py | gcloud secrets create $JWT_SECRET_NAME --data-file=- \
--replication-policy=user-managed --locations=$SERVICE_REGION

Configurare Memorystore for Redis

Per configurare Redis, sono necessarie le seguenti variabili di ambiente:

  • VPC_CONNECTOR_NAME: il nome del connettore di accesso VPC serverless per connettere i servizi Cloud Run a Memorystore for Redis. Valore consigliato: aa-integration-vpc.
  • VPC_NETWORK: la rete VPC a cui collegare il connettore di accesso VPC serverless. Il valore deve essere default se non configuri VPC per il tuo progetto Google Cloud .
  • VPC_SUBNET: il nome della rete VPC autorizzata a cui è collegata l'istanza Redis. Il valore deve essere default se non hai personalizzato le impostazioni di rete VPC.
  • REDIS_IP_RANGE: una rete IP interna non riservata per il connettore di accesso VPC serverless. È necessario uno spazio non allocato di /28. Valore consigliato: 10.8.0.0/28 (questo valore dovrebbe funzionare per la maggior parte dei nuovi progetti).
  • REDIS_INSTANCE_ID: un nome per l'istanza Redis. Valore consigliato: aa-integration-redis.

Crea un'istanza Redis nella regione dei tuoi servizi Cloud Run

Esegui questo comando:

$ gcloud redis instances create $REDIS_INSTANCE_ID --size=5 --region=$SERVICE_REGION

Puoi connetterti a un'istanza Redis da Cloud Run utilizzando l'uscita diretta o l'accesso VPC serverless.

(Facoltativo) Crea un connettore di accesso VPC serverless {:#create-svpca-connector}

Ora è facoltativo se i clienti scelgono l'uscita diretta. Se scegli l'accesso VPC serverless, devi creare un connettore di accesso VPC serverless. Per maggiori dettagli su questo passaggio, consulta il tutorial di Cloud Run.

Verifica che l'API Serverless VPC Access sia abilitata per il tuo progetto:

$ gcloud services enable vpcaccess.googleapis.com

Crea un connettore di accesso VPC serverless con un intervallo IP personalizzato:

$ gcloud compute networks vpc-access connectors create $VPC_CONNECTOR_NAME \
  --network $VPC_NETWORK \
  --region $SERVICE_REGION \
  --range $REDIS_IP_RANGE

Salva l'host Redis e la porta Redis come variabili di ambiente

  • Imposta l'indirizzo IP dell'istanza Redis sulla variabile di ambiente REDIS_HOST.
  • Imposta il numero di porta dell'istanza Redis sulla variabile di ambiente REDIS_PORT.

Esegui il deployment del servizio connettore UI

Per il servizio del connettore UI, devi disporre delle seguenti variabili di ambiente:

  • CONNECTOR_SERVICE_NAME: il nome del servizio Cloud Run del connettore UI. Valore consigliato: ui-connector.
  • CONNECTOR_IMAGE_NAME: Il nome dell'immagine del servizio UI Connector. Può essere uguale a CONNECTOR_SERVICE_NAME. Valore consigliato: ui-connector.

Crea l'immagine Docker

Nella cartella /ui-connector, esegui questo comando:

$ gcloud builds submit --tag gcr.io/$GCP_PROJECT_ID/$CONNECTOR_IMAGE_NAME

Esegui il deployment del connettore UI in Cloud Run

Nella cartella /ui-connector, esegui questo comando:

  • Se utilizzi l'uscita diretta per la connessione Redis.
$ gcloud run deploy $CONNECTOR_IMAGE_NAME \
--image gcr.io/$GCP_PROJECT_ID/$CONNECTOR_IMAGE_NAME \
--platform managed \
--service-account=$CONNECTOR_SERVICE_ACCOUNT_NAME \
--allow-unauthenticated \
--timeout 3600 \
--region $SERVICE_REGION \
--network $VPC_NETWORK \
--subnet $VPC_SUBNET \
--clear-vpc-connector \
--min-instances=1 \
--set-env-vars REDISHOST=$REDIS_HOST,REDISPORT=$REDIS_PORT,GCP_PROJECT_ID=$GCP_PROJECT_ID,AUTH_OPTION=$AUTH_OPTION \
--update-secrets=/secret/jwt_secret_key=${JWT_SECRET_NAME}:latest
  • Se utilizzi un connettore di accesso VPC serverless creato per la connessione Redis.
$ gcloud run deploy $CONNECTOR_IMAGE_NAME \
--image gcr.io/$GCP_PROJECT_ID/$CONNECTOR_IMAGE_NAME \
--platform managed \
--service-account=$CONNECTOR_SERVICE_ACCOUNT_NAME \
--allow-unauthenticated \
--timeout 3600 \
--region $SERVICE_REGION \
--vpc-connector $VPC_CONNECTOR_NAME \
--clear-network \
--min-instances=1 \
--no-cpu-throttling \
--set-env-vars REDISHOST=$REDIS_HOST,REDISPORT=$REDIS_PORT,GCP_PROJECT_ID=$GCP_PROJECT_ID,AUTH_OPTION=$AUTH_OPTION \
--update-secrets=/secret/jwt_secret_key=${JWT_SECRET_NAME}:latest

Prendi nota dell'URL del servizio per il connettore UI di cui è stato eseguito il deployment, che verrà utilizzato dai client (desktop degli agenti).

Esegui il deployment del servizio di intercettazione Cloud Pub/Sub

Per il servizio di intercettazione Pub/Sub, sono necessarie le seguenti variabili di ambiente:

  • INTERCEPTOR_SERVICE_NAME: il nome del servizio Cloud Run del tuo intercettore Cloud Pub/Sub. Valore consigliato: cloud-pubsub-interceptor.
  • INTERCEPTOR_IMAGE_NAME: il nome dell'immagine del servizio di intercettazione Cloud Pub/Sub. Può essere uguale a INTERCEPTOR_SERVICE_NAME. Valore consigliato: cloud-pubsub-interceptor.
  • INTERCEPTOR_SERVICE_ACCOUNT_NAME: il account di servizio per il runtime dell'intercettatore Cloud Pub/Sub.

Crea l'immagine Docker

Nella cartella /cloud-pubsub-interceptor, esegui questo comando: 

$ gcloud builds submit --tag gcr.io/$GCP_PROJECT_ID/$INTERCEPTOR_IMAGE_NAME

Esegui il deployment dell'intercettore Pub/Sub in Cloud Run

Nella cartella /cloud-pubsub-interceptor, esegui questo comando:

  • Se utilizzi l'uscita diretta per la connessione Redis.
$ gcloud run deploy $INTERCEPTOR_SERVICE_NAME \
--image gcr.io/$GCP_PROJECT_ID/$INTERCEPTOR_IMAGE_NAME \
--platform managed \
--service-account=$INTERCEPTOR_SERVICE_ACCOUNT_NAME \
--region $SERVICE_REGION \
--network $VPC_NETWORK \
--subnet $VPC_SUBNET \
--clear-vpc-connector \
--ingress=internal \
--min-instances=1 \
--no-cpu-throttling \
# You can also add LOGGING_FILE here to specify the logging file path on Cloud Run.
--set-env-vars REDISHOST=$REDIS_HOST,REDISPORT=$REDIS_PORT
  • Se utilizzi un connettore di accesso VPC serverless creato per la connessione Redis.
$ gcloud run deploy $INTERCEPTOR_SERVICE_NAME \
--image gcr.io/$GCP_PROJECT_ID/$INTERCEPTOR_IMAGE_NAME \
--platform managed \
--service-account=$INTERCEPTOR_SERVICE_ACCOUNT_NAME \
--region $SERVICE_REGION \
--vpc-connector $VPC_CONNECTOR_NAME \
--clear-network \
--ingress=internal \
--min-instances=1 \
# You can also add LOGGING_FILE here to specify the logging file path on Cloud Run.
--set-env-vars REDISHOST=$REDIS_HOST,REDISPORT=$REDIS_PORT

Salva l'URL di deployment

Imposta l'URL di deployment come variabile di ambiente INTERCEPTOR_SERVICE_URL.

Configurare le sottoscrizioni Cloud Pub/Sub

Le sottoscrizioni Cloud Pub/Sub utilizzano quanto segue:

  • Argomenti
  • Profilo di conversazione
  • Service account
  • Autorizzazione del service account per il servizio di intercettazione

Crea argomenti Cloud Pub/Sub

Crea un argomento Cloud Pub/Sub per ogni tipo di notifica degli eventi che ti serve da Dialogflow. I tipi di notifiche degli eventi disponibili sono:

  • Nuovi eventi di suggerimento: eventi inviati quando sono disponibili nuovi suggerimenti di Agent Assist (ad esempio, nuovi suggerimenti di Risposta rapida in risposta all'espressione di un cliente).
  • Eventi di nuovi messaggi: eventi inviati ogni volta che viene riconosciuta una nuova espressione di un agente o di un cliente (ad esempio, il cliente dice Hi).
  • Nuovi eventi del ciclo di vita della conversazione: eventi inviati per determinati cambiamenti del ciclo di vita della conversazione (ad esempio, quando una conversazione viene avviata o completata).
  • Nuovi eventi di notifica dei risultati di riconoscimento: eventi inviati quando la trascrizione intermedia viene riconosciuta da un agente o da un cliente (ad esempio, il cliente dice Hi, how can I help you?, una trascrizione intermedia è Hi how can mentre il cliente sta parlando).

Prendi nota dell'ID argomento e del nome dell'argomento per la successiva implementazione del backend.

Configurare un profilo di conversazione

Configura un profilo conversazione con gli argomenti Cloud Pub/Sub che hai creato nel passaggio precedente.

  • Quando crei un nuovo profilo conversazione, seleziona Notifiche Pub/Sub e poi Attiva notifiche Pub/Sub. Una volta abilitata, puoi selezionare le caselle accanto ai tipi di notifiche che vuoi attivare e inserire l'ID argomento per l'argomento Cloud Pub/Sub associato alla notifica.
  • Seleziona JSON come formato del messaggio per ogni argomento.

Crea un account di servizio per l'identità della sottoscrizione Pub/Sub

Crea un account di servizio che rappresenti l'identità dell'abbonamento Pub/Sub utilizzando il seguente comando:

$ gcloud iam service-accounts create cloud-run-pubsub-invoker \
     --display-name "Cloud Run Pub/Sub Invoker"

Concedi al account di servizio l'autorizzazione per richiamare il servizio di intercettazione

Esegui questo comando:

$ gcloud run services add-iam-policy-binding $INTERCEPTOR_SERVICE_NAME \ 
  --member=serviceAccount:cloud-run-pubsub-invoker@$GCP_PROJECT_ID.iam.gserviceaccount.com \
   --role=roles/run.invoker

Creare sottoscrizioni Cloud Pub/Sub per gli argomenti

Per ogni argomento creato, devi creare una sottoscrizione Cloud Pub/Sub corrispondente.

Nuovi eventi di suggerimento

Sostituisci your-new-suggestion-topic-id con l'argomento Cloud Pub/Sub che hai configurato per i nuovi suggerimenti:

$ export TOPIC_ID='your-new-suggestion-topic-id' && gcloud pubsub subscriptions create $SUBSCRIPTION_NAME --topic $TOPIC_ID \
   --push-endpoint=$INTERCEPTOR_SERVICE_URL/human-agent-assistant-event \
   --push-auth-service-account=cloud-run-pubsub-invoker@$GCP_PROJECT_ID.iam.gserviceaccount.com
Nuovi eventi di messaggistica

Sostituisci your-new-message-event-topic-id con l'argomento Cloud Pub/Sub che hai configurato per i nuovi eventi di messaggio:

$ export TOPIC_ID='your-new-message-event-topic-id' && gcloud pubsub subscriptions create $SUBSCRIPTION_NAME --topic $TOPIC_ID \
   --push-endpoint=$INTERCEPTOR_SERVICE_URL/new-message-event \
   --push-auth-service-account=cloud-run-pubsub-invoker@$GCP_PROJECT_ID.iam.gserviceaccount.com
Eventi del ciclo di vita della conversazione

Sostituisci your-conversation-lifecycle-event-topic con l'argomento Cloud Pub/Sub che hai configurato per i nuovi eventi del ciclo di vita della conversazione:

$ export TOPIC_ID='your-conversation-lifecycle-event-topic' && gcloud pubsub subscriptions create $SUBSCRIPTION_NAME --topic $TOPIC_ID \
   --push-endpoint=$INTERCEPTOR_SERVICE_URL/conversation-lifecycle-event \
   --push-auth-service-account=cloud-run-pubsub-invoker@$GCP_PROJECT_ID.iam.gserviceaccount.com
Nuovi eventi di notifica dei risultati del riconoscimento
$ export TOPIC_ID='your-new-recognition-result-notification-event-topic' && gcloud pubsub subscriptions create $SUBSCRIPTION_NAME --topic $TOPIC_ID \
   --push-endpoint=$INTERCEPTOR_SERVICE_URL/new-recognition-result-notification-event \
   --push-auth-service-account=cloud-run-pubsub-invoker@$GCP_PROJECT_ID.iam.gserviceaccount.com