Back-End-Module in Ihr System einbinden

Backend-Module bieten eine Infrastruktur für die Verarbeitung großer Mengen von funktionsbezogenen Nachrichten und die Interaktion mit der Benutzeroberfläche des Kundenservicemitarbeiter-Desktops. In dieser Anleitung wird beschrieben, wie Sie Backend-Module in Ihr Agentsystem einbinden.

Weitere Informationen zu Konzepten und Struktur von Hintergrundmodulen finden Sie in der Dokumentation Grundlagen zu Backend-Modulen.

Vorbereitung

  1. Wenn Sie sie noch nicht konfiguriert haben, installieren Sie die Google Cloud CLI.
  2. Erstellen Sie für jede Art von Ereignisbenachrichtigung, die Sie von Dialogflow benötigen, ein Cloud Pub/Sub-Thema. Notieren Sie sich die Themen-ID und den Themennamen für die spätere Backend-Bereitstellung.
  3. Konfigurieren Sie Ihr Unterhaltungsprofil mit Pub/Sub-Themen in der Agent Assist Console.

Automatisierte Bereitstellung

Die Bereitstellung kann durch ein Google Cloud -Automatisierungsskript oder Terraform automatisiert werden.

Automatisierungsskript

Weitere Informationen finden Sie unter ./deploy.sh.

Terraform-Änderungen anwenden

Sie können die Bereitstellung mit einem Automatisierungsskript für die gcloud CLI oder mit Terraform automatisieren. Führen Sie die folgenden Schritte aus, bevor Sie Terraform-Änderungen anwenden.

  1. Weisen Sie Ihrem Konto die folgenden IAM-Rollen zu:
    • 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. Erstellen Sie Images für den UI-Connector und den Cloud Pub/Sub-Interceptor und notieren Sie sich den Namen des Images.
    • Führen Sie für den UI-Connector den folgenden Befehl im Ordner ./ui-connector aus. 
      $ gcloud builds submit --tag gcr.io/$GCP_PROJECT_ID/aa-integration-backend/ui-connector
    • Führen Sie für Cloud Pub/Sub Interceptor den folgenden Befehl im Ordner ./cloud-pubsub-interceptor aus. 
      $ gcloud builds submit --tag gcr.io/$GCP_PROJECT_ID/aa-integration-backend/cloud-pubsub-interceptor
  3. Erstellen Sie mit dem folgenden Befehl einen Cloud Storage-Bucket zum Speichern des Terraform-Zustands und aktualisieren Sie den Backend-Bucket-Wert unter /terraform/backend.tf. 
    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. Exportieren Sie den Wert der erforderlichen Terraform-Variablen gcp_project_id, ui_connector_docker_image und cloud_pubsub_interceptor_docker_image. Beispiel: export TF_VAR_gcp_project_id='you-gcp-project-id'. Alternativ können Sie die Werte auch direkt in /terraform/variables.tf eingeben.
  5. Passen Sie die Authentifizierungsmethode an, indem Sie die auth.check_auth()-Methode unter /ui-connector/auth.py ändern.

Wenn Sie diese Schritte mit Cloud Build automatisieren möchten, folgen Sie dieser Anleitung und verwenden Sie die Build-Konfigurationsdatei ./terraform_cloudbuild.yaml. Damit Cloud Build die Dienste bereitstellen kann, müssen Sie dem Cloud Build-Dienstkonto die in Schritt 1 aufgeführten IAM-Rollen zuweisen.

Manuelle Bereitstellung

In den folgenden Schritten wird beschrieben, wie Sie Backend-Module manuell bereitstellen.

Umgebungsvariablen einrichten

Um die Befehle für die Bereitstellung zu vereinfachen, empfehlen wir, die folgenden nützlichen Umgebungsvariablen in Ihrer Shell festzulegen. Sie können die Variablen mit dem folgenden Beispielbefehl festlegen:

$ export GCP_PROJECT_ID='aa-integration-service'

Legen Sie die folgenden Umgebungsvariablen fest:

  • GCP_PROJECT_ID: Die Projekt-ID Ihres Cloud Platform-Projekts, in dem sich die zugehörigen Ressourcen befinden. Beispiel: my-project.
  • SERVICE_REGION: Der Standort oder die Region Ihrer Dienste und zugehörigen Google Cloud Ressourcen. Plattformressourcen. Beispiel: us-central1.

Administratorkonto einrichten

Wir empfehlen, separate Google Cloud Konten für die Dienstverwaltung und die Laufzeitidentität zu verwenden. Die Dienstverwaltung wird hauptsächlich von Personen mit Google-Konten durchgeführt, während die Laufzeitidentität Cloud Run-Diensten Berechtigungen über Dienstkonten erteilt, um den Zugriff auf erforderliche Ressourcen zu ermöglichen.

Administratorkonto für Menschen vorbereiten

Wenn Sie ein Konto verwenden möchten, das bereits die Berechtigungen „Bearbeiter“ oder „Inhaber“ für Ihr Projekt hat, können Sie mit dem nächsten Abschnitt fortfahren.

Zum Verwalten der Backend-Infrastruktur richten Sie ein Administratorkonto ein und weisen Sie ihm die folgenden IAM-Rollen (Identity and Access Management) zu. Ihre Berechtigungen sind alle in den einfachen Rollen „Bearbeiter“ und „Inhaber“ enthalten.

  • roles/secretmanager.admin (Secret Manager-Administrator): Verwalten Sie Secrets, die in Secret Manager für die JWT-Generierung und ‑Überprüfung gespeichert sind.
  • roles/run.admin (Cloud Run Admin): Cloud Run-Dienste bereitstellen und verwalten.
  • roles/iam.serviceAccountUser (Dienstkontonutzer): Erteilen Sie Cloud Run-Laufzeitdienstkonten iam.serviceAccounts.actAs-Berechtigungen.
  • roles/cloudbuild.builds.editor (Cloud Build-Bearbeiter): Erstellen Sie Docker-Images für die Integrationsdienste mit Cloud Build.
  • Artifact Registry-Administrator: Speichert und verwaltet erstellte Docker-Images für die Integrationsdienste.
  • roles/pubsub.editor (Cloud Pub/Sub Editor): Erstellen und verwalten Sie Cloud Pub/Sub-Themen und ‑Abos.
  • roles/redis.admin (Redis-Administrator): Erstellt und verwaltet Memorystore for Redis-Ressourcen.

Verwenden Sie den Google Cloud CLI-Befehl add-iam-policy-binding, um einem menschlichen Konto IAM-Rollen zuzuweisen. Hier ein Beispielbefehl:

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

Administratorkonto in gcloud festlegen

Ersetzen Sie $ADMIN_ACCOUNT im folgenden Beispiel durch das Administratorkonto, das Sie verwenden möchten (z. B. myaccount@gmail.com):

$ gcloud config set account $ADMIN_ACCOUNT

Dienstkonten einrichten

Cloud Run-Dienste oder -Jobs werden standardmäßig als Compute Engine-Standarddienstkonto ausgeführt. Anstatt die Standardeinstellung beizubehalten, empfehlen wir, jedem Cloud Run-Dienst eine dedizierte Identität zuzuweisen. Dazu weisen Sie ihm ein nutzerverwaltetes Dienstkonto mit den minimal erforderlichen Berechtigungen zu. Wenn Sie das Standarddienstkonto beibehalten möchten, können Sie mit dem nächsten Schritt Umgebungsvariablen festlegen fortfahren.

Zwei Dienstkonten für jede Cloud Run-Laufzeit erstellen

  1. Ersetzen Sie den Wert von $CONNECTOR_SERVICE_ACCOUNT_ID und $INTERCEPTOR_SERVICE_ACCOUNT_ID, falls erforderlich, und führen Sie die folgenden Befehle aus, um die Dienstkonten zu erstellen:

    $ 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. Verwenden Sie den folgenden Beispielbefehl, um den Dienstkonten für den UI-Connector und den Cloud Pub/Sub-Connector die folgenden Rollen zuzuweisen:

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

Weisen Sie dem Dienstkonto des UI-Connectors die folgenden IAM-Rollen zu:

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

Weisen Sie dem Dienstkonto des Cloud Pub/Sub-Connectors die folgenden Rollen zu:

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

Umgebungsvariablen festlegen

Legen Sie die Werte der folgenden Umgebungsvariablen auf die Dienstkonten fest, die Sie gerade erstellt haben, oder auf das Compute Engine-Standarddienstkonto in Ihrem Projekt.

  1. CONNECTOR_SERVICE_ACCOUNT: Das Dienstkonto für die Laufzeit des UI-Connectors. Beispiel: aa-ui-connector@my-project-id.iam.gserviceaccount.com.
  2. INTERCEPTOR_SERVICE_ACCOUNT: Das Dienstkonto für die Cloud Pub/Sub Interceptor-Laufzeit. Beispiel: aa-pubsub-interceptor@my-project-id.iam.gserviceaccount.com.

Nutzerauthentifizierungsmethode anpassen

Das Code-Repository unterstützt sowohl Backend-Nutzer als auch Nutzer des Frontend-Moduls für Genesys Cloud und Twilio.

  1. Öffnen Sie im Code-Repository die Datei ui_connector/auth.py.

  2. Geben Sie den unterstützten Identitätsanbieter an, indem Sie die Umgebungsvariable AUTH_OPTION festlegen, oder implementieren Sie Ihre Authentifizierungsmethode mit auth.check_auth.

    Standardmäßig ist AUTH_OPTION leer und keine Nutzer dürfen JWT beim UI Connector-Dienst registrieren. Unterstützte Werte:

    • Salesforce: Das Autorisierungstoken mit Salesforce OpenID Connect überprüfen. Erforderliche Umgebungsvariable: SALESFORCE_ORGANIZATION_ID.
    • SalesforceLWC: Überprüfen Sie ein Salesforce-OAuth-Clientanmeldedaten-Authentifizierungstoken mit dem oauth2/userinfo-REST-Endpunkt. Erforderliche Umgebungsvariablen: SALESFORCE_ORGANIZATION_ID, SALESFORCE_DOMAIN.
    • GenesysCloud: Überprüfen Sie das Autorisierungstoken mit der UsersAPI des Genesys SDK.
    • Twilio: Das Authentifizierungstoken für Twilio wird überprüft. Erforderliche Umgebungsvariable: TWILIO_FLEX_ENVIRONMENT.
    • Skip: Überspringen der Überprüfung des Authentifizierungstokens. Sie sollte nicht in der Produktion verwendet werden.

    Beispiel: 

    $ export AUTH_OPTION='Salesforce'

    Für jeden Tokentyp kann eine andere Validierungsmethode verwendet werden. Sie entscheiden, wie das Token validiert wird. Ohne Änderungen gibt auth.check_auth für jede Anfrage false zurück.

Wenn Sie die Ursprünge einschränken möchten, die auf Ihren Dienst zugreifen können, ändern Sie den Wert der Variablen config.CORS_ALLOWED_ORIGINS. Mit dem Standardwert * kann jeder Ursprung Ihren Dienst aufrufen.

JWT-Secret-Schlüssel generieren und speichern

Damit der UI-Connector-Dienst sichere Authentifizierungstokens an den Client zurücksenden kann, muss er sie mit einem JWT-geheimen Schlüssel verschlüsseln. Der Wert des Schlüssels kann ein beliebiger String sein, sollte aber eindeutig und schwer zu erraten sein.

Dieser geheime Schlüssel wird in Secret Manager gespeichert.

Umgebungsvariable festlegen

  • JWT_SECRET_NAME: Der Name des geheimen Schlüssels im Secret Manager. Das kann ein beliebiger Name sein. Empfohlener Wert: aa-integration-jwt-secret.

Schlüssel generieren

Wir empfehlen, einen zufälligen Hash als JWT-Schlüssel zu generieren, damit er nicht von Angreifern erraten werden kann. Dazu können Sie python secrets verwenden, um sichere Zufallszahlen zu generieren.

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

Schlüssel in Secret Manager speichern

Ersetzen Sie im folgenden Beispielbefehl my_key durch den geheimen Schlüssel, den Sie verwenden möchten.

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

Memorystore for Redis einrichten

Für die Einrichtung von Redis benötigen Sie die folgenden Umgebungsvariablen:

  • VPC_CONNECTOR_NAME: Der Name Ihres Connectors für serverlosen VPC-Zugriff zum Verbinden von Cloud Run-Diensten mit Memorystore for Redis. Empfohlener Wert: aa-integration-vpc.
  • VPC_NETWORK: Das VPC-Netzwerk, an das der Connector für Serverloser VPC-Zugriff angehängt wird. Der Wert sollte default sein, wenn Sie keine VPC für Ihr Google Cloud Projekt einrichten.
  • VPC_SUBNET: Der Name des autorisierten VPC-Netzwerk, an das Ihre Redis-Instanz angehängt ist. Der Wert sollte default sein, wenn Sie die VPC-Netzwerkeinstellungen nicht angepasst haben.
  • REDIS_IP_RANGE: Ein nicht reserviertes internes IP-Netzwerk für Ihren Connector für Serverloser VPC-Zugriff. Es ist nicht zugewiesener Speicherplatz in einem Umfang von /28 erforderlich. Empfohlener Wert: 10.8.0.0/28 (dieser Wert sollte für die meisten neuen Projekte funktionieren).
  • REDIS_INSTANCE_ID: Ein Name für Ihre Redis-Instanz. Empfohlener Wert: aa-integration-redis.

Redis-Instanz in der Region Ihrer Cloud Run-Dienste erstellen

Führen Sie dazu diesen Befehl aus:

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

Sie können über Cloud Run mithilfe von Direct Egress oder serverlosem VPC-Zugriff eine Verbindung zu einer Redis-Instanz herstellen.

Connector für Serverloser VPC-Zugriff erstellen {:#create-svpca-connector} (Optional)

Das ist jetzt optional, wenn Kunden „Direct Egress“ auswählen. Wenn Sie den Serverloser VPC-Zugriff auswählen, müssen Sie einen Connector für Serverloser VPC-Zugriff erstellen. Weitere Informationen zu diesem Schritt finden Sie im Cloud Run-Tutorial.

Prüfen Sie, ob die Serverless VPC Access API für Ihr Projekt aktiviert ist:

$ gcloud services enable vpcaccess.googleapis.com

Erstellen Sie einen Connector für Serverloser VPC-Zugriff mit einem benutzerdefinierten IP-Bereich:

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

Redis-Host und Redis-Port als Umgebungsvariablen speichern

  • Legen Sie die IP-Adresse Ihrer Redis-Instanz auf die Umgebungsvariable REDIS_HOST fest.
  • Legen Sie die Portnummer Ihrer Redis-Instanz auf die Umgebungsvariable REDIS_PORT fest.

UI-Connector-Dienst bereitstellen

Für den UI-Connector-Dienst benötigen Sie die folgenden Umgebungsvariablen:

  • CONNECTOR_SERVICE_NAME: Der Cloud Run-Dienstname Ihres UI-Connectors. Empfohlener Wert: ui-connector.
  • CONNECTOR_IMAGE_NAME: Der Bildname Ihres UI Connector-Dienstes. Sie kann mit CONNECTOR_SERVICE_NAME identisch sein. Empfohlener Wert: ui-connector.

Docker-Image erstellen

Führen Sie im Ordner /ui-connector den folgenden Befehl aus:

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

UI-Connector in Cloud Run bereitstellen

Führen Sie im Ordner /ui-connector den folgenden Befehl aus:

  • Wenn Sie Direct Egress für die Verbindung zu Redis verwenden.
$ 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
  • Wenn Sie einen erstellten Connector für Serverloser VPC-Zugriff für die Redis-Verbindung verwenden.
$ 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

Notieren Sie sich die Dienst-URL für den bereitgestellten UI-Connector, die von Clients (Agent-Desktops) verwendet wird.

Cloud Pub/Sub-Interceptor-Dienst bereitstellen

Für den Pub/Sub-Interceptor-Dienst benötigen Sie die folgenden Umgebungsvariablen:

  • INTERCEPTOR_SERVICE_NAME: Der Cloud Run-Dienstname Ihres Cloud Pub/Sub-Interceptors. Empfohlener Wert: cloud-pubsub-interceptor.
  • INTERCEPTOR_IMAGE_NAME: Der Bildname Ihres Cloud Pub/Sub-Interceptor-Dienstes. Er kann mit INTERCEPTOR_SERVICE_NAME identisch sein. Empfohlener Wert: cloud-pubsub-interceptor.
  • INTERCEPTOR_SERVICE_ACCOUNT_NAME: Das Dienstkonto für die Cloud Pub/Sub-Interceptor-Laufzeit.

Docker-Image erstellen

Führen Sie im Ordner /cloud-pubsub-interceptor den folgenden Befehl aus: 

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

Pub/Sub-Interceptor in Cloud Run bereitstellen

Führen Sie im Ordner /cloud-pubsub-interceptor den folgenden Befehl aus:

  • Wenn Sie Direct Egress für die Verbindung zu Redis verwenden.
$ 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
  • Wenn Sie einen erstellten Connector für Serverloser VPC-Zugriff für die Redis-Verbindung verwenden.
$ 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

Bereitgestellte URL speichern

Legen Sie die bereitgestellte URL als Umgebungsvariable INTERCEPTOR_SERVICE_URL fest.

Cloud Pub/Sub-Abos konfigurieren

Cloud Pub/Sub-Abos verwenden Folgendes:

  • Themen
  • Unterhaltungsprofil
  • Dienstkonto
  • Dienstkontoberechtigung für Interceptor-Dienst

Cloud Pub/Sub-Themen erstellen

Erstellen Sie ein Cloud Pub/Sub-Thema für jede Art von Ereignisbenachrichtigung, die Sie von Dialogflow benötigen. Die verfügbaren Benachrichtigungstypen für Ereignisse sind:

  • Neue Vorschlagsereignisse: Ereignisse, die gesendet werden, wenn neue Agent Assist-Vorschläge verfügbar sind, z. B. neue Smart Reply-Vorschläge als Reaktion auf eine Äußerung des Kunden.
  • Ereignisse für neue Nachrichten: Ereignisse, die gesendet werden, wenn eine neue Äußerung von einem Kundenservicemitarbeiter oder Kunden erkannt wird (z. B. wenn der Kunde Hi sagt).
  • Neue Ereignisse für den Unterhaltungslebenszyklus: Ereignisse, die für bestimmte Änderungen des Unterhaltungslebenszyklus gesendet werden, z. B. wenn eine Unterhaltung begonnen oder abgeschlossen wird.
  • Benachrichtigungsereignisse für neue Erkennungsergebnisse: Ereignisse, die gesendet werden, wenn ein Zwischen-Transkript von einem Kundenservicemitarbeiter oder Kunden erkannt wird (z. B. wenn der Kunde Hi, how can I help you? sagt, wird ein Zwischen-Transkript Hi how can erstellt, während der Kunde spricht).

Notieren Sie sich die Themen-ID und den Namen des Themas für die spätere Backend-Bereitstellung.

Unterhaltungsprofil konfigurieren

Konfigurieren Sie ein Konversationsprofil mit den Cloud Pub/Sub-Themen, die Sie im vorherigen Schritt erstellt haben.

  • Wenn Sie ein neues Konversationsprofil erstellen, wählen Sie Pub/Sub-Benachrichtigungen und dann Pub/Sub-Benachrichtigungen aktivieren aus. Nach der Aktivierung können Sie die Kästchen neben den Benachrichtigungstypen ankreuzen, die Sie aktivieren möchten, und die Themen-ID für das zugehörige Cloud Pub/Sub-Thema der Benachrichtigung eingeben.
  • Wählen Sie für jedes Thema JSON als Nachrichtenformat aus.

Dienstkonto für die Pub/Sub-Aboidentität erstellen

Erstellen Sie mit dem folgenden Befehl ein Dienstkonto, das die Pub/Sub-Abonnementidentität darstellt:

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

Gewähren Sie dem Dienstkonto die Berechtigung zum Aufrufen Ihres Interceptor-Dienstes.

Führen Sie dazu diesen Befehl aus:

$ 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

Cloud Pub/Sub-Abos für Themen erstellen

Für jedes Thema, das Sie erstellt haben, müssen Sie ein entsprechendes Cloud Pub/Sub-Abo erstellen.

Neue Ereignisse für Vorschläge

Ersetzen Sie your-new-suggestion-topic-id durch das Cloud Pub/Sub-Thema, das Sie für neue Vorschläge konfiguriert haben:

$ 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
Neue Nachrichtenereignisse

Ersetzen Sie your-new-message-event-topic-id durch das Cloud Pub/Sub-Thema, das Sie für neue Nachrichtenereignisse konfiguriert haben:

$ 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
Lifecycle-Events für Unterhaltungen

Ersetzen Sie your-conversation-lifecycle-event-topic durch das Cloud Pub/Sub-Thema, das Sie für neue Ereignisse im Konversationslebenszyklus konfiguriert haben:

$ 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
Neue Benachrichtigungsereignisse für Erkennungsergebnisse
$ 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