Intégrer des modules backend à votre système

Les modules de backend fournissent une infrastructure permettant de traiter de grands volumes de messages liés aux fonctionnalités et d'interagir avec l'UI de l'agent. Ce tutoriel vous guide tout au long du processus d'intégration des modules de backend à votre système d'agent.

Pour en savoir plus sur les concepts et la structure des modules de backend, consultez la documentation Principes de base des modules de backend.

Prérequis

  1. Si vous ne l'avez pas encore configurée, installez la Google Cloud CLI.
  2. Créez un sujet Cloud Pub/Sub pour chaque type de notification d'événement dont vous avez besoin dans Dialogflow. Notez l'ID et le nom du sujet pour le déploiement du backend ultérieur.
  3. Configurez votre profil de conversation à l'aide de la console Agent Assist avec les sujets Pub/Sub.

Déploiement automatisé

Le déploiement peut être automatisé par un script d'automatisation Google Cloud ou Terraform.

Script d'automatisation

Pour en savoir plus, consultez ./deploy.sh.

Appliquer les modifications Terraform

Vous pouvez automatiser le déploiement à l'aide d'un script d'automatisation gcloud CLI ou de Terraform. Avant d'appliquer les modifications Terraform, procédez comme suit.

  1. Attribuez les rôles IAM suivants à votre compte :
    • 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. Créez des images pour le connecteur d'interface utilisateur et pour l'intercepteur Cloud Pub/Sub, puis notez le nom de l'image.
    • Pour le connecteur d'UI, exécutez la commande suivante dans le dossier ./ui-connector. 
      $ gcloud builds submit --tag gcr.io/$GCP_PROJECT_ID/aa-integration-backend/ui-connector
    • Pour l'intercepteur Cloud Pub/Sub, exécutez la commande suivante dans le dossier ./cloud-pubsub-interceptor. 
      $ gcloud builds submit --tag gcr.io/$GCP_PROJECT_ID/aa-integration-backend/cloud-pubsub-interceptor
  3. Créez un bucket Cloud Storage pour stocker l'état Terraform et mettez à jour la valeur du bucket backend à /terraform/backend.tf à l'aide de la commande suivante. 
    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. Exportez la valeur des variables Terraform requises gcp_project_id, ui_connector_docker_image et cloud_pubsub_interceptor_docker_image. Exemple : export TF_VAR_gcp_project_id='you-gcp-project-id'. Vous pouvez également saisir directement leurs valeurs dans /terraform/variables.tf.
  5. Personnalisez la méthode d'authentification en modifiant la méthode auth.check_auth() dans /ui-connector/auth.py.

Si vous souhaitez automatiser ces étapes à l'aide de Cloud Build, suivez ces instructions et utilisez le fichier de configuration de compilation ./terraform_cloudbuild.yaml. Pour permettre à Cloud Build de déployer les services, vous devez accorder au compte de service Cloud Build les rôles IAM listés à l'étape 1.

Déploiement manuel

Les étapes suivantes expliquent comment déployer manuellement les modules de backend.

Configurer des variables d'environnement

Pour simplifier les commandes de déploiement, nous vous recommandons de définir les variables d'environnement utiles suivantes dans votre shell. Vous pouvez définir les variables à l'aide de l'exemple de commande suivant :

$ export GCP_PROJECT_ID='aa-integration-service'

Définissez les variables d'environnement suivantes :

  • GCP_PROJECT_ID : ID du projet Cloud Platform qui héberge les ressources associées. Exemple : my-project.
  • SERVICE_REGION : emplacement ou région de vos services et des ressources Google Cloud associées. Ressources de la plate-forme. Exemple : us-central1.

Configurer un compte administrateur

Nous vous recommandons d'utiliser des comptes Google Cloud distincts pour l'administration des services et l'identité d'exécution. L'administration des services est principalement effectuée par des humains disposant de comptes Google, tandis que l'identité d'exécution accorde des autorisations aux services Cloud Run à l'aide de comptes de service pour permettre l'accès aux ressources nécessaires.

Préparer le compte administrateur humain

Si vous prévoyez d'utiliser un compte qui dispose déjà des autorisations d'éditeur ou de propriétaire dans votre projet, vous pouvez passer directement à la section suivante.

Pour gérer l'infrastructure de backend, créez un compte administrateur et accordez-lui les rôles Identity and Access Management (IAM) suivants. Leurs autorisations sont toutes incluses dans les rôles de base Éditeur et Propriétaire.

  • roles/secretmanager.admin (administrateur Secret Manager) : gérez les secrets stockés dans Secret Manager pour la génération et la validation des jetons JWT.
  • roles/run.admin (Administrateur Cloud Run) : déployer et gérer les services Cloud Run.
  • roles/iam.serviceAccountUser (Utilisateur du compte de service) : accordez les autorisations iam.serviceAccounts.actAs aux comptes de service d'exécution Cloud Run.
  • roles/cloudbuild.builds.editor (Éditeur Cloud Build) : créez des images Docker pour les services d'intégration à l'aide de Cloud Build.
  • Administrateur Artifact Registry : stockez et gérez les images Docker compilées pour les services d'intégration.
  • roles/pubsub.editor (Éditeur Cloud Pub/Sub) : créez et gérez des sujets et des abonnements Cloud Pub/Sub.
  • roles/redis.admin (Administrateur Redis) : créez et gérez des ressources Memorystore pour Redis.

Pour attribuer des rôles IAM à un compte utilisateur, utilisez la commande Google Cloud CLI add-iam-policy-binding. Voici un exemple de commande :

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

Définir le compte administrateur humain dans gcloud

Dans l'exemple suivant, remplacez $ADMIN_ACCOUNT par le compte administrateur que vous souhaitez utiliser (par exemple, myaccount@gmail.com) :

$ gcloud config set account $ADMIN_ACCOUNT

Configurer des comptes de service

Par défaut, les services ou jobs Cloud Run s'exécutent en tant que compte de service Compute Engine par défaut. Au lieu de laisser la valeur par défaut, nous vous recommandons d'attribuer une identité dédiée à chaque service Cloud Run en lui attribuant un compte de service géré par l'utilisateur avec l'ensemble minimal d'autorisations requises. Si vous prévoyez de conserver le compte de service par défaut, vous pouvez passer directement à la section Définir des variables d'environnement.

Créez deux comptes de service pour chaque exécution Cloud Run.

  1. Pour créer les comptes de service, remplacez la valeur de $CONNECTOR_SERVICE_ACCOUNT_ID et $INTERCEPTOR_SERVICE_ACCOUNT_ID, puis exécutez les commandes suivantes :

    $ 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. Utilisez l'exemple de commande suivant pour attribuer les rôles suivants aux comptes de service du connecteur d'interface utilisateur et du connecteur 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'

Attribuez les rôles IAM suivants au compte de service du connecteur d'interface utilisateur :

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

Attribuez les rôles suivants au compte de service du connecteur Cloud Pub/Sub :

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

Définir des variables d'environnement

Définissez les valeurs des variables d'environnement suivantes sur les comptes de service que vous venez de créer ou sur le compte de service Compute Engine par défaut de votre projet.

  1. CONNECTOR_SERVICE_ACCOUNT : compte de service pour l'exécution du connecteur d'interface utilisateur. Exemple : aa-ui-connector@my-project-id.iam.gserviceaccount.com.
  2. INTERCEPTOR_SERVICE_ACCOUNT : compte de service pour l'exécution de l'intercepteur Cloud Pub/Sub. Exemple : aa-pubsub-interceptor@my-project-id.iam.gserviceaccount.com.

Personnaliser la méthode d'authentification des utilisateurs

Le dépôt de code est compatible avec les utilisateurs de backend et ceux du module de frontend pour Genesys Cloud et Twilio.

  1. Dans le dépôt de code, ouvrez le fichier ui_connector/auth.py.

  2. Spécifiez le fournisseur d'identité compatible en définissant la variable d'environnement AUTH_OPTION ou implémentez votre méthode d'authentification avec auth.check_auth.

    Par défaut, AUTH_OPTION est vide et aucun utilisateur n'est autorisé à enregistrer un jeton JWT avec le service UI Connector. Valeurs autorisées :

    • Salesforce : validez le jeton d'authentification à l'aide de Salesforce OpenID Connect. Variable d'environnement requise : SALESFORCE_ORGANIZATION_ID.
    • SalesforceLWC : validez un jeton d'authentification des identifiants client OAuth Salesforce à l'aide du point de terminaison REST oauth2/userinfo. Variables d'environnement requises : SALESFORCE_ORGANIZATION_ID, SALESFORCE_DOMAIN.
    • GenesysCloud : validez le jeton d'authentification à l'aide de l'API Users du SDK Genesys.
    • Twilio : validez le jeton d'authentification pour Twilio. Variable d'environnement requise : TWILIO_FLEX_ENVIRONMENT.
    • Skip : ignorer la validation du jeton d'authentification. Elle ne doit pas être utilisée en production.

    Exemple : 

    $ export AUTH_OPTION='Salesforce'

    Chaque type de jeton peut avoir un moyen de validation différent. Vous décidez comment le jeton est validé. Sans aucune modification, auth.check_auth renvoie false pour chaque requête.

Pour limiter les origines pouvant accéder à votre service, modifiez la valeur de la variable config.CORS_ALLOWED_ORIGINS. La valeur par défaut * permet à n'importe quelle origine d'accéder à votre service.

Générer et stocker une clé secrète JWT

Pour que le service de connecteur d'UI renvoie des jetons d'authentification sécurisés au client, il doit les chiffrer à l'aide d'une clé secrète JWT. La valeur de la clé peut être n'importe quelle chaîne arbitraire, mais elle doit être unique et difficile à deviner.

Cette clé secrète sera stockée dans Secret Manager.

Définir une variable d'environnement

  • JWT_SECRET_NAME : nom de la clé secrète dans Secret Manager. Il peut s'agir de n'importe quel nom arbitraire. Valeur recommandée : aa-integration-jwt-secret.

Générez la clé.

Nous vous recommandons de générer un hachage aléatoire comme clé secrète JWT afin qu'elle ne puisse pas être devinée par des pirates informatiques. Pour ce faire, vous pouvez utiliser python secrets afin de générer des nombres aléatoires sécurisés.

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

Stocker la clé dans Secret Manager

Dans l'exemple de commande suivant, remplacez my_key par la clé secrète que vous prévoyez d'utiliser.

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

Configurer Memorystore pour Redis

Pour configurer Redis, vous avez besoin des variables d'environnement suivantes :

  • VPC_CONNECTOR_NAME : nom de votre connecteur d'accès au VPC sans serveur pour connecter les services Cloud Run à Memorystore pour Redis. Valeur recommandée : aa-integration-vpc.
  • VPC_NETWORK : réseau VPC auquel associer votre connecteur d'accès au VPC sans serveur. La valeur doit être default si vous ne configurez pas de VPC pour votre projet Google Cloud .
  • VPC_SUBNET : nom du réseau VPC autorisé auquel votre instance Redis est associée. La valeur doit être default si vous n'avez pas personnalisé les paramètres du réseau VPC.
  • REDIS_IP_RANGE : réseau IP interne non réservé pour votre connecteur d'accès au VPC sans serveur. Un espace non attribué de /28 est requis. Valeur recommandée : 10.8.0.0/28 (cette valeur devrait fonctionner pour la plupart des nouveaux projets).
  • REDIS_INSTANCE_ID : nom de votre instance Redis. Valeur recommandée : aa-integration-redis.

Créez une instance Redis dans la région de vos services Cloud Run.

Exécutez la commande suivante :

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

Vous pouvez vous connecter à une instance Redis à partir de Cloud Run à l'aide de la sortie directe ou de l'accès au VPC sans serveur.

Créer un connecteur d'accès au VPC sans serveur {:#create-svpca-connector} (facultatif)

Cette étape est désormais facultative si les clients choisissent la sortie directe. Si vous choisissez l'accès au VPC sans serveur, vous devrez créer un connecteur d'accès au VPC sans serveur. Pour en savoir plus sur cette étape, consultez le tutoriel Cloud Run.

Vérifiez que l'API Serverless VPC Access est activée pour votre projet :

$ gcloud services enable vpcaccess.googleapis.com

Créez un connecteur d'accès au VPC sans serveur avec une plage d'adresses IP personnalisée :

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

Enregistrez l'hôte et le port Redis en tant que variables d'environnement.

  • Définissez l'adresse IP de votre instance Redis sur la variable d'environnement REDIS_HOST.
  • Définissez le numéro de port de votre instance Redis sur la variable d'environnement REDIS_PORT.

Déployer le service de connecteur d'interface utilisateur

Pour le service de connecteur d'UI, vous avez besoin des variables d'environnement suivantes :

  • CONNECTOR_SERVICE_NAME : nom du service Cloud Run de votre connecteur d'UI. Valeur recommandée : ui-connector.
  • CONNECTOR_IMAGE_NAME : nom de l'image de votre service UI Connector. Elle peut être identique à CONNECTOR_SERVICE_NAME. Valeur recommandée : ui-connector.

Compiler l'image Docker

Sous le dossier /ui-connector, exécutez la commande suivante :

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

Déployer le connecteur d'interface utilisateur sur Cloud Run

Sous le dossier /ui-connector, exécutez la commande suivante :

  • Si vous utilisez la sortie directe pour vous connecter à 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 vous utilisez un connecteur d'accès au VPC sans serveur créé pour la connexion 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

Notez l'URL du service pour le connecteur d'UI déployé, qui sera utilisé par les clients (postes de travail des agents).

Déployer le service d'intercepteur Cloud Pub/Sub

Pour le service d'intercepteur Pub/Sub, vous avez besoin des variables d'environnement suivantes :

  • INTERCEPTOR_SERVICE_NAME : nom du service Cloud Run de votre intercepteur Cloud Pub/Sub. Valeur recommandée : cloud-pubsub-interceptor.
  • INTERCEPTOR_IMAGE_NAME : nom de l'image de votre service d'intercepteur Cloud Pub/Sub. Elle peut être identique à INTERCEPTOR_SERVICE_NAME. Valeur recommandée : cloud-pubsub-interceptor.
  • INTERCEPTOR_SERVICE_ACCOUNT_NAME : compte de service pour l'exécution de l'intercepteur Cloud Pub/Sub.

Compiler l'image Docker

Sous le dossier /cloud-pubsub-interceptor, exécutez la commande suivante : 

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

Déployer un intercepteur Pub/Sub sur Cloud Run

Sous le dossier /cloud-pubsub-interceptor, exécutez la commande suivante :

  • Si vous utilisez la sortie directe pour vous connecter à 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 vous utilisez un connecteur d'accès au VPC sans serveur créé pour la connexion 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

Enregistrer l'URL déployée

Définissez l'URL déployée comme variable d'environnement INTERCEPTOR_SERVICE_URL.

Configurer les abonnements Cloud Pub/Sub

Les abonnements Cloud Pub/Sub utilisent les éléments suivants :

  • Thèmes
  • Profil de conversation
  • Compte de service
  • Autorisation du compte de service pour le service d'intercepteur

Créer des sujets Cloud Pub/Sub

Créez un sujet Cloud Pub/Sub pour chaque type de notification d'événement dont vous avez besoin dans Dialogflow. Les types de notifications d'événements disponibles sont les suivants :

  • Nouveaux événements de suggestion : événements envoyés lorsque de nouvelles suggestions Agent Assist sont disponibles (par exemple, de nouvelles suggestions de réponses intelligentes en réponse à une requête client).
  • Événements de nouveaux messages : événements envoyés chaque fois qu'une nouvelle expression est reconnue de la part d'un agent ou d'un client (par exemple, le client dit Hi).
  • Nouveaux événements du cycle de vie des conversations : événements envoyés pour certains changements du cycle de vie des conversations (par exemple, lorsqu'une conversation est lancée ou terminée).
  • Nouveaux événements de notification des résultats de reconnaissance : événements envoyés lorsqu'une transcription intermédiaire est reconnue à partir d'un agent ou d'un client (par exemple, si le client dit Hi, how can I help you?, une transcription intermédiaire Hi how can est générée pendant que le client parle).

Notez l'ID et le nom du thème pour le déploiement du backend ultérieur.

Configurer un profil de conversation

Configurez un profil de conversation avec les sujets Cloud Pub/Sub que vous avez créés à l'étape précédente.

  • Lorsque vous créez un profil de conversation, sélectionnez Notifications Pub/Sub, puis Activer les notifications Pub/Sub. Une fois activées, vous pouvez cocher les types de notifications que vous souhaitez activer et saisir l'ID du sujet Cloud Pub/Sub associé à la notification.
  • Sélectionnez JSON comme format de message pour chaque sujet.

Créer un compte de service pour l'identité de l'abonnement Pub/Sub

Créez un compte de service représentant l'identité de l'abonnement Pub/Sub à l'aide de la commande suivante :

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

Autorisez le compte de service à appeler votre service d'intercepteur.

Exécutez la commande suivante :

$ 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

Créer des abonnements Cloud Pub/Sub pour les sujets

Pour chaque sujet que vous avez créé, vous devez créer un abonnement Cloud Pub/Sub correspondant.

Nouveaux événements de suggestions

Remplacez your-new-suggestion-topic-id par le sujet Cloud Pub/Sub que vous avez configuré pour les nouvelles suggestions :

$ 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
Nouveaux événements de message

Remplacez your-new-message-event-topic-id par le sujet Cloud Pub/Sub que vous avez configuré pour les événements de nouveaux messages :

$ 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
Événements du cycle de vie des conversations

Remplacez your-conversation-lifecycle-event-topic par le sujet Cloud Pub/Sub que vous avez configuré pour les nouveaux événements de cycle de vie des conversations :

$ 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
Nouveaux événements de notification des résultats de reconnaissance
$ 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