Integra 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 y para interactuar con la IU del escritorio del agente. En este instructivo, se te guiará por el proceso de integración de módulos de backend con tu sistema de agentes.

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

Requisitos previos

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

Implementación automatizada

La implementación se puede automatizar con 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 detalles.

Aplica los cambios de Terraform

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

  1. Otorga los siguientes roles de IAM 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. Compila imágenes para el conector de IU y para el interceptor de Cloud Pub/Sub, y anota el nombre de la imagen.
    • Para el conector de IU, ejecuta el siguiente comando en la carpeta ./ui-connector. 
      $ gcloud builds submit --tag gcr.io/$GCP_PROJECT_ID/aa-integration-backend/ui-connector
    • Para 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 bucket de Cloud Storage para almacenar el estado de Terraform y actualiza el valor del bucket 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 requeridas gcp_project_id, ui_connector_docker_image y cloud_pubsub_interceptor_docker_image. Ejemplo: export TF_VAR_gcp_project_id='you-gcp-project-id'. Como alternativa, puedes completar 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 deseas automatizar estos pasos con Cloud Build, sigue esta instrucción y usa el archivo de configuración de compilación ./terraform_cloudbuild.yaml. Para permitir que Cloud Build implemente los servicios, debes otorgar a la cuenta de servicio de Cloud Build los roles de IAM que se indican en el paso 1.

Implementación manual

En los siguientes pasos, se explica cómo implementar módulos de backend de forma manual.

Configura variables de entorno

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

$ export GCP_PROJECT_ID='aa-integration-service'

Configura las siguientes variables de entorno:

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

Configura una cuenta de administrador

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

Prepara la cuenta administrativa humana

Si planeas usar una cuenta que ya tiene permisos de editor o propietario en tu proyecto, puedes avanzar a la siguiente sección.

Para administrar la infraestructura de backend, establece una cuenta de administrador y otórgale los siguientes roles de Identity and Access Management (IAM). Todos sus permisos se incluyen en los roles básicos de Editor y Propietario.

  • roles/secretmanager.admin (administrador de Secret Manager): Administra los secretos almacenados en Secret Manager para la generación y verificación de JWT.
  • roles/run.admin (Administrador de Cloud Run): Implementa y administra servicios de Cloud Run.
  • roles/iam.serviceAccountUser (Usuario de cuenta de servicio): Otorga permisos de iam.serviceAccounts.actAs a las cuentas de servicio del entorno de ejecución de Cloud Run.
  • roles/cloudbuild.builds.editor (Editor de Cloud Build): Compila imágenes de Docker para los servicios de integración con Cloud Build.
  • Administrador de Artifact Registry: Almacena y administra imágenes de Docker compiladas para los servicios de integración.
  • roles/pubsub.editor (Editor de Cloud Pub/Sub): Crea y administra temas y suscripciones de Cloud Pub/Sub.
  • roles/redis.admin (Administrador de Redis): Crea y administra recursos de Memorystore para Redis.

Para otorgar roles de IAM a una cuenta humana, usa el comando de add-iam-policy-binding de Google Cloud CLI. El siguiente es un ejemplo de un comando:

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

Configura la cuenta administrativa humana en gcloud

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

$ gcloud config set account $ADMIN_ACCOUNT

Configura cuentas de servicio

De forma predeterminada, los servicios o trabajos de Cloud Run se ejecutan como la cuenta de servicio predeterminada de Compute Engine. En lugar de dejar la configuración predeterminada, te recomendamos que asignes una identidad exclusiva a cada servicio de Cloud Run. Para ello, asígnale una cuenta de servicio administrada por el usuario con el conjunto mínimo requerido de permisos. Si planeas conservar la cuenta de servicio predeterminada, puedes avanzar y configurar variables de entorno.

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

  1. Para crear las cuentas de servicio, reemplaza el valor 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 IU 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'

Otorga los siguientes roles de IAM a la cuenta de servicio del conector de la IU:

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

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

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

Configure las variables de entorno

Establece los valores de las siguientes variables de entorno para que sean las cuentas de servicio que acabas de crear o la cuenta de servicio predeterminada de Compute Engine en tu proyecto.

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

Personaliza el método de autenticación del usuario

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

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

  2. Especifica el proveedor de identidad compatible 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 no se permite que ningún usuario registre JWT con el servicio de UI Connector. Valores admitidos:

    • Salesforce: Verifica el token de autorización con OpenID Connect de Salesforce. Variable de entorno obligatoria: SALESFORCE_ORGANIZATION_ID.
    • SalesforceLWC: Verifica un token de autorización de credenciales de cliente de OAuth de Salesforce con el extremo de REST oauth2/userinfo. Variables de entorno obligatorias: SALESFORCE_ORGANIZATION_ID y SALESFORCE_DOMAIN.
    • GenesysCloud: Verifica el token de autorización con la UsersAPI del SDK de Genesys.
    • Twilio: Verifica el token de autorización de Twilio. Variable de entorno obligatoria: TWILIO_FLEX_ENVIRONMENT.
    • Skip: Omite la verificación del token de autorización. No debe usarse 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 para 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.

Genera y almacena una clave secreta de JWT

Para que el servicio del conector de IU envíe tokens de autenticación seguros al cliente, debe encriptarlos con una clave secreta de 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.

Configura la variable de entorno

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

Genera la clave

Te recomendamos que generes un hash aleatorio como clave secreta del JWT para que los atacantes no puedan adivinarlo. 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'

Almacena la clave en Secret Manager

En el siguiente ejemplo de comando, reemplaza my_key por la clave secreta que planeas usar.

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

Configura Memorystore para Redis

Para configurar Redis, necesitas las siguientes variables de entorno:

  • VPC_CONNECTOR_NAME: Es el nombre de tu conector de Acceso a VPC sin servidores para conectar servicios de Cloud Run a Memorystore para Redis. Valor recomendado: aa-integration-vpc.
  • VPC_NETWORK: Es la red de VPC a la que conectarás tu conector de Acceso a VPC sin servidores. El valor debe ser default si no configuras la VPC para tu proyecto Google Cloud .
  • VPC_SUBNET: Es el nombre de la red de VPC autorizada a la que está adjunta tu instancia de Redis. El valor debe ser default si no personalizaste la configuración de la red de VPC.
  • REDIS_IP_RANGE: Una red IP interna no reservada para tu conector de Acceso a VPC sin servidores. Se requiere un valor /28 de espacio no asignado. Valor recomendado: 10.8.0.0/28 (este valor debería funcionar para la mayoría de los proyectos nuevos).
  • REDIS_INSTANCE_ID: Es un nombre para tu 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 con la salida directa o el acceso a VPC sin servidores.

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

Ahora es opcional si los clientes eligen la salida directa. Si eliges el Acceso a VPC sin servidores, deberás crear un conector de Acceso a VPC sin servidores. Para obtener más detalles sobre este paso, consulta el instructivo de Cloud Run.

Verifica que la API de Acceso a VPC sin servidores esté habilitada para tu proyecto:

$ gcloud services enable vpcaccess.googleapis.com

Crea un conector de Acceso a VPC sin servidores con un rango de IP personalizado:

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

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

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

Implementa el servicio del conector de la IU

Para el servicio del conector de la IU, necesitas las siguientes variables de entorno:

  • CONNECTOR_SERVICE_NAME: Es el nombre del servicio de Cloud Run de tu conector de IU. Valor recomendado: ui-connector.
  • CONNECTOR_IMAGE_NAME: Es el nombre de la imagen de tu servicio de conector de IU. Puede ser igual a la de CONNECTOR_SERVICE_NAME. Valor recomendado: ui-connector.

Compila 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

Implementa el conector de la IU en Cloud Run

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

  • Si se usa la salida directa 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 \
--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 servidores creado para la conexión 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 \
--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

Toma nota de la URL del servicio del conector de la IU implementado, que usarán los clientes (escritorios de agentes).

Implementa 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: Es el nombre del servicio de Cloud Run de tu interceptor de Cloud Pub/Sub. Valor recomendado: cloud-pubsub-interceptor.
  • INTERCEPTOR_IMAGE_NAME: Es el nombre de la imagen de tu servicio de interceptor de Cloud Pub/Sub. Puede ser igual a la de INTERCEPTOR_SERVICE_NAME. Valor recomendado: cloud-pubsub-interceptor.
  • INTERCEPTOR_SERVICE_ACCOUNT_NAME: Es la cuenta de servicio del tiempo de ejecución del interceptor de Cloud Pub/Sub.

Compila 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

Implementa el interceptor de Pub/Sub en Cloud Run

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

  • Si se usa la salida directa 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 \
--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 servidores creado para la conexión 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 \
--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 implementación

Establece la URL implementada como la variable de entorno INTERCEPTOR_SERVICE_URL.

Configura suscripciones a Cloud Pub/Sub

Las suscripciones a Cloud Pub/Sub usan lo siguiente:

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

Crea temas de Cloud Pub/Sub

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

  • Eventos de sugerencias nuevas: Son los eventos que se envían cuando hay nuevas sugerencias de Agent Assist disponibles (por ejemplo, nuevas sugerencias de Respuesta inteligente en respuesta a una expresión del cliente).
  • Eventos de mensaje nuevo: Son los eventos que se envían cada vez que se reconoce una expresión nueva de un agente o cliente (por ejemplo, el cliente dice Hi).
  • Nuevos eventos de ciclo de vida de la conversación: Son eventos que se envían para ciertos cambios en el ciclo de vida de la conversación (por ejemplo, cuando se inicia una conversación o cuando se completa).
  • Nuevos eventos de notificación de resultados de reconocimiento: Son eventos que se envían cuando se reconoce una transcripción intermedia de un agente o cliente (por ejemplo, el cliente dice Hi, how can I help you?, se genera una transcripción intermedia Hi how can mientras el cliente habla).

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

Cómo configurar un perfil de conversación

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

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

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

Crea una cuenta de servicio que represente la identidad de 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"

Otorga permiso a la cuenta de servicio 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

Crea suscripciones a temas de Cloud Pub/Sub

Para cada tema que creaste, debes crear una suscripción correspondiente a Cloud Pub/Sub.

Nuevos eventos de sugerencia

Reemplaza your-new-suggestion-topic-id por el tema de Cloud Pub/Sub que configuraste 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

Reemplaza your-new-message-event-topic-id por el tema de Cloud Pub/Sub que configuraste 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 de ciclo de vida de la conversación

Reemplaza your-conversation-lifecycle-event-topic por el tema de Cloud Pub/Sub que configuraste para los eventos del ciclo de vida de conversaciones nuevas:

$ 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