Webhook-Dienst erstellen

Der vorkonfigurierte Agent, den Sie im letzten Schritt erstellt haben, kann keine dynamischen Daten wie Kontostände bereitstellen, da alles im Agenten hartcodiert ist. In diesem Schritt der Anleitung erstellen Sie einen webhook, der dem Kundenservicemitarbeiter dynamische Daten zur Verfügung stellen kann. In dieser Anleitung werden Cloud Run-Funktionen verwendet, um den Webhook zu hosten, da sie einfach sind. Es gibt jedoch viele andere Möglichkeiten, einen Webhook-Dienst zu hosten. Im Beispiel wird auch die Programmiersprache Go verwendet. Sie können jedoch jede von Cloud Run-Funktionen unterstützte Sprache verwenden.

Funktion erstellen

Cloud Run-Funktionen können mit der Google Cloud Console erstellt werden (Dokumentation ansehen, Console öffnen). So erstellen Sie eine Funktion für diese Anleitung:

  1. Ihr Dialogflow-Agent und die Funktion müssen sich im selben Projekt befinden. Das ist die einfachste Möglichkeit, Dialogflow sicheren Zugriff auf Ihre Funktion zu gewähren. Wählen Sie in der Google Cloud Console Ihr Projekt aus, bevor Sie die Funktion erstellen.

    Zur Projektauswahl

  2. Öffnen Sie die Übersichtsseite zu Cloud Run-Funktionen.

    Cloud Run-Funktionen – Übersicht

  3. Klicken Sie auf Funktion erstellen und legen Sie die folgenden Felder fest:

    • Umgebung: 1. Generation
    • Funktionsname: tutorial-banking-webhook
    • Region: Wenn Sie für Ihren Kundenservicemitarbeiter eine Region angegeben haben, verwenden Sie dieselbe Region.
    • HTTP-Triggertyp: HTTP
    • URL: Klicken Sie hier auf die Schaltfläche „Kopieren“ und speichern Sie den Wert. Sie benötigen diese URL, wenn Sie den Webhook konfigurieren.
    • Authentifizierung: Authentifizierung verlangen
    • HTTPS erforderlich: angeklickt

  4. Klicken Sie auf Speichern.

  5. Klicken Sie auf Weiter. Sie benötigen keine speziellen Laufzeit-, Build-, Verbindungs- oder Sicherheitseinstellungen.

  6. Legen Sie die Werte für die folgenden Felder fest:

    • Laufzeit: Wählen Sie die neueste Go-Laufzeit aus.
    • Quellcode: Inline-Editor
    • Einstiegspunkt: HandleWebhookRequest

  7. Ersetzen Sie den Code durch Folgendes: 

    package estwh

import (
	"context"
	"encoding/json"
	"fmt"
	"log"
	"net/http"
	"os"
	"strings"

	"cloud.google.com/go/spanner"
  "google.golang.org/grpc/codes"
)

// client is a Spanner client, created only once to avoid creation
// for every request.
// See: https://cloud.google.com/functions/docs/concepts/go-runtime#one-time_initialization
var client *spanner.Client

func init() {
	// If using a database, these environment variables will be set.
	pid := os.Getenv("PROJECT_ID")
	iid := os.Getenv("SPANNER_INSTANCE_ID")
	did := os.Getenv("SPANNER_DATABASE_ID")
	if pid != "" && iid != "" && did != "" {
		db := fmt.Sprintf("projects/%s/instances/%s/databases/%s",
			pid, iid, did)
		log.Printf("Creating Spanner client for %s", db)
		var err error
		// Use the background context when creating the client,
		// but use the request context for calls to the client.
		// See: https://cloud.google.com/functions/docs/concepts/go-runtime#contextcontext
		client, err = spanner.NewClient(context.Background(), db)
		if err != nil {
			log.Fatalf("spanner.NewClient: %v", err)
		}
	}
}

type queryResult struct {
	Action     string                 `json:"action"`
	Parameters map[string]interface{} `json:"parameters"`
}

type text struct {
	Text []string `json:"text"`
}

type message struct {
	Text text `json:"text"`
}

// webhookRequest is used to unmarshal a WebhookRequest JSON object. Note that
// not all members need to be defined--just those that you need to process.
// As an alternative, you could use the types provided by
// the Dialogflow protocol buffers:
// https://godoc.org/google.golang.org/genproto/googleapis/cloud/dialogflow/v2#WebhookRequest
type webhookRequest struct {
	Session     string      `json:"session"`
	ResponseID  string      `json:"responseId"`
	QueryResult queryResult `json:"queryResult"`
}

// webhookResponse is used to marshal a WebhookResponse JSON object. Note that
// not all members need to be defined--just those that you need to process.
// As an alternative, you could use the types provided by
// the Dialogflow protocol buffers:
// https://godoc.org/google.golang.org/genproto/googleapis/cloud/dialogflow/v2#WebhookResponse
type webhookResponse struct {
	FulfillmentMessages []message `json:"fulfillmentMessages"`
}

// accountBalanceCheck handles the similar named action
func accountBalanceCheck(ctx context.Context, request webhookRequest) (
	webhookResponse, error) {
	account := request.QueryResult.Parameters["account"].(string)
	account = strings.ToLower(account)
	var table string
	if account == "savings account" {
		table = "Savings"
	} else {
		table = "Checking"
	}
	s := "Your balance is $0"
	if client != nil {
		// A Spanner client exists, so access the database.
		// See: https://pkg.go.dev/cloud.google.com/go/spanner#ReadOnlyTransaction.ReadRow
		row, err := client.Single().ReadRow(ctx,
			table,
			spanner.Key{1}, // The account ID
			[]string{"Balance"})
		if err != nil {
			if spanner.ErrCode(err) == codes.NotFound {
				log.Printf("Account %d not found", 1)
			} else {
				return webhookResponse{}, err
			}
		} else {
			// A row was returned, so check the value
			var balance int64
			err := row.Column(0, &balance)
			if err != nil {
				return webhookResponse{}, err
			}
			s = fmt.Sprintf("Your balance is $%.2f", float64(balance)/100.0)
		}
	}
	response := webhookResponse{
		FulfillmentMessages: []message{
			{
				Text: text{
					Text: []string{s},
				},
			},
		},
	}
	return response, nil
}

// Define a type for handler functions.
type handlerFn func(ctx context.Context, request webhookRequest) (
	webhookResponse, error)

// Create a map from action to handler function.
var handlers map[string]handlerFn = map[string]handlerFn{
	"account.balance.check": accountBalanceCheck,
}

// handleError handles internal errors.
func handleError(w http.ResponseWriter, err error) {
	log.Printf("ERROR: %v", err)
	http.Error(w,
		fmt.Sprintf("ERROR: %v", err),
		http.StatusInternalServerError)
}

// HandleWebhookRequest handles WebhookRequest and sends the WebhookResponse.
func HandleWebhookRequest(w http.ResponseWriter, r *http.Request) {
	var request webhookRequest
	var response webhookResponse
	var err error

	// Read input JSON
	if err = json.NewDecoder(r.Body).Decode(&request); err != nil {
		handleError(w, err)
		return
	}
	log.Printf("Request: %+v", request)

	// Get the action from the request, and call the corresponding
	// function that handles that action.
	action := request.QueryResult.Action
	if fn, ok := handlers[action]; ok {
		response, err = fn(r.Context(), request)
	} else {
		err = fmt.Errorf("Unknown action: %s", action)
	}
	if err != nil {
		handleError(w, err)
		return
	}
	log.Printf("Response: %+v", response)

	// Send response
	if err = json.NewEncoder(w).Encode(&response); err != nil {
		handleError(w, err)
		return
	}
}

  8. Klicken Sie auf Bereitstellen.

  9. Warten Sie, bis die Statusanzeige anzeigt, dass die Funktion bereitgestellt wurde. Sehen Sie sich in der Zwischenzeit den Code an, den Sie gerade bereitgestellt haben.

Webhook für Ihren Kundenservicemitarbeiter konfigurieren

Nachdem der Webhook als Dienst vorhanden ist, müssen Sie ihn mit Ihrem Agent verknüpfen. Dies geschieht über die Auftragsausführung. So aktivieren und verwalten Sie die Auftragsausführung für Ihren Agent:

  1. Rufen Sie die Dialogflow ES-Konsole auf.
  2. Wählen Sie den vorkonfigurierten Agenten aus, den Sie gerade erstellt haben.
  3. Wählen Sie im Menü der linken Seitenleiste Auftragsausführung aus.
  4. Stellen Sie für das Feld Webhook die Option Aktiviert ein.
  5. Geben Sie die URL ein, die Sie oben kopiert haben. Lassen Sie alle anderen Felder leer.
  6. Klicken Sie unten auf der Seite auf Speichern.

Screenshot: Aktivieren der Auftragsausführung

Nachdem die Auftragsausführung für den Kundenservicemitarbeiter aktiviert wurde, müssen Sie sie für einen Intent aktivieren:

  1. Wählen Sie im Menü der linken Seitenleiste Intents aus.
  2. Wählen Sie die Absicht account.balance.check aus.
  3. Scrollen Sie nach unten zum Abschnitt Fulfillment.
  4. Webhook-Aufruf für diesen Intent aktivieren einschalten.
  5. Klicken Sie auf Speichern.

Agent testen

Ihr Agent kann jetzt getestet werden. Klicken Sie auf die Schaltfläche Agent testen, um den Simulator zu öffnen. Versuchen Sie, die folgende Unterhaltung mit dem Kundenservicemitarbeiter zu führen:

Konversationsrunde Ich Agent
1 Hallo! Hallo, vielen Dank, dass Sie sich für die ACME-Bank entschieden haben.
2 Ich möchte meinen Kontostand wissen. Für welches Konto soll das Guthaben angezeigt werden: Sparkonto oder Girokonto?
3 Wird überprüft Ihr aktuelles Guthaben: 0,00 $

Bei der dritten Gesprächsrunde haben Sie „Girokonto“ als Kontotyp angegeben. Die Absicht account.balance.check hat einen Parameter namens account. In dieser Unterhaltung ist dieser Parameter auf „Prüfen“ festgelegt. Der Intent hat außerdem den Aktionswert „account.balance.check“. Der Webhook-Dienst wird aufgerufen und die Parameter- und Aktionswerte werden übergeben.

Wenn Sie sich den Webhook-Code oben ansehen, sehen Sie, dass diese Aktion den Aufruf einer Funktion mit ähnlichem Namen auslöst. Mit der Funktion wird der Kontostand ermittelt. Die Funktion prüft, ob bestimmte Umgebungsvariablen mit Informationen zur Verbindung zur Datenbank festgelegt sind. Wenn diese Umgebungsvariablen nicht festgelegt sind, verwendet die Funktion ein hartcodiertes Kontoguthaben. In den nächsten Schritten ändern Sie die Umgebung für die Funktion, damit Daten aus einer Datenbank abgerufen werden.

Fehlerbehebung

Der Webhook-Code enthält Logging-Anweisungen. Wenn Probleme auftreten, sehen Sie sich die Logs für Ihre Funktion an.

Weitere Informationen

Weitere Informationen zu den oben genannten Schritten finden Sie hier:

Zurück
Vordefinierten Agent erstellen
Weiter
Datenbank abfragen