Integrar módulos de backend con tu sistema

Los módulos de backend proporcionan una infraestructura para procesar grandes volúmenes de mensajes relacionados con funciones e interactuar con la interfaz de usuario del escritorio del agente. En este tutorial se explica el proceso de integración de módulos de backend con tu sistema de agente.

Para obtener más información sobre los conceptos y la estructura de los módulos de backend, consulta la documentación sobre los conceptos básicos de los módulos de backend.

Requisitos previos

  1. Si no lo has configurado, instala Google Cloud CLI.
  2. Crea un tema de Cloud Pub/Sub para cada tipo de notificación de evento que necesites de Dialogflow. Anota el ID y el nombre del tema para la implementación posterior en el backend.
  3. Configura tu perfil de conversación con la consola de Agent Assist y temas de Pub/Sub.

Despliegue automático

La implementación se puede automatizar mediante una Google Cloud secuencia de comandos de automatización o Terraform.

Secuencia de comandos de automatización

Puedes consultar ./deploy.sh para obtener más información.

Aplicar cambios de Terraform

Puedes automatizar la implementación con una secuencia de comandos de automatización de la CLI de gcloud o con Terraform. Antes de aplicar los cambios de Terraform, completa los siguientes pasos.

  1. Concede los siguientes roles de gestión de identidades y accesos a tu cuenta:
    • 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 imágenes para UI Connector y para Cloud Pub/Sub Interceptor, y anota el nombre de la imagen.
    • En UI Connector, ejecuta el siguiente comando en la carpeta ./ui-connector. 
      $ gcloud builds submit --tag gcr.io/$GCP_PROJECT_ID/aa-integration-backend/ui-connector
    • En el caso de Cloud Pub/Sub Interceptor, ejecuta el siguiente comando en la carpeta ./cloud-pubsub-interceptor. 
      $ gcloud builds submit --tag gcr.io/$GCP_PROJECT_ID/aa-integration-backend/cloud-pubsub-interceptor
  3. Crea un segmento de Cloud Storage para almacenar el estado de Terraform y actualiza el valor del segmento de backend en /terraform/backend.tf con el siguiente 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. Exporta el valor de las variables de Terraform obligatorias gcp_project_id, ui_connector_docker_image y cloud_pubsub_interceptor_docker_image. Ejemplo: export TF_VAR_gcp_project_id='you-gcp-project-id'. También puedes rellenar sus valores directamente en /terraform/variables.tf.
  5. Personaliza el método de autenticación modificando el método auth.check_auth() en /ui-connector/auth.py.

Si quieres automatizar estos pasos con Cloud Build, sigue estas instrucciones y usa el archivo de configuración de compilación ./terraform_cloudbuild.yaml. Para permitir que Cloud Build despliegue los servicios, debes conceder a la cuenta de servicio de Cloud Build los roles de gestión de identidades y accesos que se indican en el paso 1.

Despliegue manual

En los siguientes pasos se explica cómo implementar módulos de backend manualmente.

Configurar variables de entorno

Para simplificar los comandos de implementación, te recomendamos que definas las siguientes variables de entorno útiles en tu shell. Puedes definir las variables con el siguiente comando de ejemplo:

$ export GCP_PROJECT_ID='aa-integration-service'

Define las siguientes variables de entorno:

  • GCP_PROJECT_ID: el ID del proyecto de Cloud Platform que aloja los recursos relacionados. Ejemplo: my-project
  • SERVICE_REGION: la ubicación o la región de tus servicios y los recursos relacionados. Google Cloud Recursos de la plataforma. Ejemplo: us-central1

Configurar una cuenta administrativa

Te recomendamos que uses cuentas independientes para la administración de servicios y la identidad de tiempo de ejecución. Google Cloud La administración de servicios la realizan principalmente personas con cuentas de Google, mientras que la identidad de tiempo de ejecución concede permisos a los servicios de Cloud Run mediante cuentas de servicio para habilitar el acceso a los recursos necesarios.

Preparar la cuenta administrativa humana

Si tienes previsto usar una cuenta que ya tenga permisos de editor o propietario en tu proyecto, puedes ir directamente a la siguiente sección.

Para gestionar la infraestructura backend, crea una cuenta de administrador y concédele los siguientes roles de Gestión de Identidades y Accesos (IAM). Todos sus permisos se incluyen en los roles básicos Editor y Propietario.

  • roles/secretmanager.admin (Administrador de Secret Manager): gestiona los secretos almacenados en Secret Manager para generar y verificar JWTs.
  • roles/run.admin (Administrador de Cloud Run): despliega y gestiona servicios de Cloud Run.
  • roles/iam.serviceAccountUser (Usuario de cuenta de servicio): concede permisos a las iam.serviceAccounts.actAscuentas de servicio de tiempo de ejecución de Cloud Run.
  • roles/cloudbuild.builds.editor (Editor de versiones de Cloud): crea imágenes de Docker para los servicios de integración con Cloud Build.
  • Administrador de Artifact Registry: almacena y gestiona imágenes de Docker compiladas para los servicios de integración.
  • roles/pubsub.editor (Editor de Cloud Pub/Sub): crea y gestiona temas y suscripciones de Cloud Pub/Sub.
  • roles/redis.admin (Administrador de Redis): crea y gestiona recursos de Memorystore para Redis.

Para asignar roles de IAM a una cuenta humana, usa el comando de la add-iam-policy-binding CLI de Google Cloud. A continuación, se muestra un ejemplo de comando:

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

Definir la cuenta de administrador humana en gcloud

Sustituye $ADMIN_ACCOUNT por la cuenta de administrador que quieras usar (por ejemplo, myaccount@gmail.com) en el siguiente ejemplo:

$ gcloud config set account $ADMIN_ACCOUNT

Configurar cuentas de servicio

De forma predeterminada, los servicios o los trabajos de Cloud Run se ejecutan como la cuenta de servicio predeterminada de Compute Engine. En lugar de dejar el valor predeterminado, te recomendamos que asignes a cada servicio de Cloud Run una identidad específica. Para ello, asígnale una cuenta de servicio gestionada por el usuario con el conjunto mínimo de permisos necesarios. Si tienes previsto conservar la cuenta de servicio predeterminada, puedes saltar a la sección sobre cómo definir variables de entorno.

Crea dos cuentas de servicio para cada entorno de ejecución de Cloud Run

  1. Para crear las cuentas de servicio, sustituye los valores de $CONNECTOR_SERVICE_ACCOUNT_ID y $INTERCEPTOR_SERVICE_ACCOUNT_ID (si es necesario) y ejecuta los siguientes comandos:

    $ 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. Usa el siguiente comando de ejemplo para asignar los siguientes roles a las cuentas de servicio del conector de la interfaz de usuario y del conector de 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'

Asigna los siguientes roles de gestión de identidades y accesos a la cuenta de servicio del conector de la interfaz de usuario:

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

Concede los siguientes roles a la cuenta de servicio del conector de Cloud Pub/Sub:

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

Establece variables de entorno:

Asigna a las siguientes variables de entorno los valores de las cuentas de servicio que acabas de crear o de la cuenta de servicio predeterminada de Compute Engine de tu proyecto.

  1. CONNECTOR_SERVICE_ACCOUNT: la cuenta de servicio del tiempo de ejecución del conector de la interfaz de usuario. Ejemplo: aa-ui-connector@my-project-id.iam.gserviceaccount.com
  2. INTERCEPTOR_SERVICE_ACCOUNT: la cuenta de servicio del tiempo de ejecución de interceptores de Cloud Pub/Sub. Ejemplo: aa-pubsub-interceptor@my-project-id.iam.gserviceaccount.com

Personalizar el método de autenticación de usuarios

El repositorio de código admite tanto a los usuarios del backend como a los del módulo frontend de Genesys Cloud y Twilio.

  1. En el repositorio de código, abre el archivo ui_connector/auth.py.

  2. Especifica el proveedor de identidades admitido configurando la variable de entorno AUTH_OPTION o implementa tu método de autenticación con auth.check_auth.

    De forma predeterminada, AUTH_OPTION está vacío y ningún usuario puede registrar JWT con el servicio UI Connector. Valores admitidos:

    • Salesforce: verifica el token de autenticación mediante Salesforce OpenID Connect. Variable de entorno obligatoria: SALESFORCE_ORGANIZATION_ID.
    • SalesforceLWC: verifica un token de autenticación de credenciales de cliente de OAuth de Salesforce mediante el endpoint REST oauth2/userinfo. Variables de entorno obligatorias: SALESFORCE_ORGANIZATION_ID y SALESFORCE_DOMAIN.
    • GenesysCloud: verifica el token de autenticación con la API Users de Genesys SDK.
    • Twilio: verifica el token de autenticación de Twilio. Variable de entorno obligatoria: TWILIO_FLEX_ENVIRONMENT.
    • Skip: omite la verificación del token de autenticación. No se debe usar en producción.

    Ejemplo: 

    $ export AUTH_OPTION='Salesforce'

    Cada tipo de token puede tener un medio de validación diferente. Tú decides cómo se valida el token. Sin ningún cambio, auth.check_auth devuelve false en cada solicitud.

Para limitar los orígenes que pueden acceder a tu servicio, cambia el valor de la variable config.CORS_ALLOWED_ORIGINS. El valor predeterminado * permitirá que cualquier origen visite tu servicio.

Generar y almacenar una clave secreta JWT

Para que el servicio del conector de interfaz de usuario pueda enviar tokens de autenticación seguros al cliente, debe cifrarlos con una clave secreta JWT. El valor de la clave puede ser cualquier cadena arbitraria, aunque debe ser único y difícil de adivinar.

Esta clave secreta se almacenará en Secret Manager.

Definir variable de entorno

  • JWT_SECRET_NAME: nombre de la clave secreta en Secret Manager. Puede ser cualquier nombre arbitrario. Valor recomendado: aa-integration-jwt-secret.

Generar la clave

Recomendamos generar un hash aleatorio como clave secreta de JWT para que los atacantes no puedan adivinarla. Para ello, puedes usar python secrets para generar números aleatorios seguros.

# 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'

Almacenar la clave en Secret Manager

En el siguiente comando de ejemplo, sustituye my_key por la clave secreta que quieras usar.

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

Configurar Memorystore para Redis

Para configurar Redis, necesitas las siguientes variables de entorno:

  • VPC_CONNECTOR_NAME: el nombre del conector de acceso a VPC sin servidor para conectar servicios de Cloud Run a Memorystore para Redis. Valor recomendado: aa-integration-vpc.
  • VPC_NETWORK: la red de VPC a la que se adjuntará el conector de Acceso a VPC sin servidor. El valor debe ser default si no configura una VPC para su proyecto Google Cloud .
  • VPC_SUBNET: nombre de la red VPC autorizada a la que está conectada tu instancia de Redis. El valor debe ser default si no has personalizado la configuración de la red VPC.
  • REDIS_IP_RANGE: una red IP interna no reservada para tu conector de acceso a VPC sin servidor. Se necesita /28 de espacio no asignado. Valor recomendado: 10.8.0.0/28 (este valor debería funcionar en la mayoría de los proyectos nuevos).
  • REDIS_INSTANCE_ID: nombre de la instancia de Redis. Valor recomendado: aa-integration-redis.

Crea una instancia de Redis en la región de tus servicios de Cloud Run

Ejecuta el siguiente comando:

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

Puedes conectarte a una instancia de Redis desde Cloud Run mediante salida directa o acceso a VPC sin servidor.

Crea un conector de Acceso a VPC sin servidor {:#create-svpca-connector} (opcional).

Ahora es opcional si los clientes eligen Salida directa. Si eliges Acceso a VPC sin servidor, tendrás que crear un conector de Acceso a VPC sin servidor. Para obtener más información sobre este paso, consulta el tutorial de Cloud Run.

Comprueba que la API Acceso a VPC sin servidor esté habilitada en tu proyecto:

$ gcloud services enable vpcaccess.googleapis.com

Crea un conector de acceso a VPC sin servidor con un intervalo de IP personalizado:

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

Guardar el host y el puerto de Redis como variables de entorno

  • Asigna la dirección IP de tu instancia de Redis a la variable de entorno REDIS_HOST.
  • Define el número de puerto de tu instancia de Redis en la variable de entorno REDIS_PORT.

Implementar el servicio de conector de la interfaz de usuario

En el caso del servicio de conector de interfaz de usuario, necesitas las siguientes variables de entorno:

  • CONNECTOR_SERVICE_NAME: el nombre del servicio Cloud Run de tu conector de interfaz de usuario. Valor recomendado: ui-connector.
  • CONNECTOR_IMAGE_NAME: nombre de la imagen de tu servicio UI Connector. Puede ser la misma URL que la que se indica en CONNECTOR_SERVICE_NAME. Valor recomendado: ui-connector.

Crear la imagen de Docker

En la carpeta /ui-connector, ejecuta el siguiente comando:

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

Desplegar el conector de interfaz de usuario en Cloud Run

En la carpeta /ui-connector, ejecuta el siguiente comando:

  • Si se usa Salida directa para conectarse a 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
  • Si se usa un conector de acceso a VPC sin servidor creado para la conexión de 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

Anota la URL del servicio del conector de interfaz de usuario implementado, que usarán los clientes (escritorios de agentes).

Desplegar el servicio de interceptor de Cloud Pub/Sub

Para el servicio de interceptor de Pub/Sub, necesitas las siguientes variables de entorno:

  • INTERCEPTOR_SERVICE_NAME: el nombre del servicio Cloud Run de tu interceptor de Cloud Pub/Sub. Valor recomendado: cloud-pubsub-interceptor.
  • INTERCEPTOR_IMAGE_NAME: nombre de la imagen de tu servicio de interceptor de Cloud Pub/Sub. Puede ser la misma URL que la que se indica en INTERCEPTOR_SERVICE_NAME. Valor recomendado: cloud-pubsub-interceptor.
  • INTERCEPTOR_SERVICE_ACCOUNT_NAME: la cuenta de servicio del tiempo de ejecución del interceptor de Cloud Pub/Sub.

Crear la imagen de Docker

En la carpeta /cloud-pubsub-interceptor, ejecuta el siguiente comando: 

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

Desplegar el interceptor de Pub/Sub en Cloud Run

En la carpeta /cloud-pubsub-interceptor, ejecuta el siguiente comando:

  • Si se usa Salida directa para conectarse a 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
  • Si se usa un conector de acceso a VPC sin servidor creado para la conexión de 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

Guarda la URL de la aplicación implementada

Define la URL implementada como la variable de entorno INTERCEPTOR_SERVICE_URL.

Configurar suscripciones de Cloud Pub/Sub

Las suscripciones de Cloud Pub/Sub usan lo siguiente:

  • Temas
  • Perfil de conversación
  • Cuenta de servicio
  • Permiso de cuenta de servicio para el servicio de interceptor

Crear temas de Cloud Pub/Sub

Crea un tema de Cloud Pub/Sub para cada tipo de notificación de evento que necesites de Dialogflow. Los tipos de notificaciones de eventos disponibles son los siguientes:

  • Eventos de sugerencias nuevas: eventos que se envían cuando hay nuevas sugerencias de Asistente (por ejemplo, nuevas sugerencias de Respuesta inteligente en respuesta a una expresión del cliente).
  • Eventos de mensajes nuevos: eventos que se envían cada vez que se reconoce una nueva expresión de un agente o un cliente (por ejemplo, cuando el cliente dice Hi).
  • Nuevos eventos del ciclo de vida de la conversación: eventos enviados para determinados cambios en el ciclo de vida de la conversación (por ejemplo, cuando se inicia o se completa una conversación).
  • Nuevos eventos de notificación de resultados de reconocimiento: eventos que se envían cuando se reconoce una transcripción intermedia de un agente o un cliente (por ejemplo, el cliente dice Hi, how can I help you? y la transcripción intermedia es Hi how can mientras el cliente habla).

Anota el ID y el nombre del tema para la implementación posterior en el backend.

Configurar un perfil de conversación

Configura un perfil de conversación con los temas de Cloud Pub/Sub que has creado en el paso anterior.

  • Cuando crees un perfil de conversación, selecciona Notificaciones de Pub/Sub y, a continuación, Habilitar notificaciones de Pub/Sub. Una vez habilitadas, puedes marcar las casillas situadas junto a los tipos de notificaciones que quieras habilitar e introducir el ID del tema de Cloud Pub/Sub asociado a la notificación.
  • Selecciona JSON como formato de mensaje para cada tema.

Crear una cuenta de servicio para la identidad de la suscripción de Pub/Sub

Crea una cuenta de servicio que represente la identidad de la suscripción de Pub/Sub con el siguiente comando:

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

Concede a la cuenta de servicio permiso para invocar tu servicio de interceptor

Ejecuta el siguiente 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

Crear suscripciones de Cloud Pub/Sub para temas

Por cada tema que hayas creado, debes crear una suscripción de Cloud Pub/Sub correspondiente.

Nuevos eventos de sugerencias

Sustituye your-new-suggestion-topic-id por el tema de Cloud Pub/Sub que hayas configurado para las sugerencias nuevas:

$ 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
Nuevos eventos de mensajes

Sustituye your-new-message-event-topic-id por el tema de Cloud Pub/Sub que hayas configurado para los eventos de mensajes nuevos:

$ 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
Eventos del ciclo de vida de la conversación

Sustituye your-conversation-lifecycle-event-topic por el tema de Cloud Pub/Sub que has configurado para los nuevos eventos del ciclo de vida de la conversación:

$ 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
Nuevos eventos de notificación de resultados de reconocimiento
$ 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