Webhook-Dienst erstellen

Den vordefinierten Agent, den Sie im letzten Schritt erstellt haben können keine dynamischen Daten wie Kontostand, da alles im Agent hartcodiert ist. In diesem Schritt der Anleitung erstellen Sie ein Webhook die dem Agent 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, Konsole öffnen). So erstellen Sie eine Funktion für diese Anleitung:

  1. Es ist wichtig, dass Ihr Dialogflow-Agent und die Funktion sich beide im selben Projekt befinden. Das ist die einfachste Möglichkeit, Dialogflow sicheren Zugriff auf Ihre Funktion zu gewähren. Bevor Sie die Funktion erstellen, wählen Sie Ihr Projekt in der Google Cloud Console aus.

    Zur Projektauswahl

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

    Cloud Run-Funktionen – Übersicht

  3. Klicken Sie auf Funktion erstellen und legen Sie Werte für 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: aktiviert

  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 erfolgreich bereitgestellt wurde. Während Sie warten, überprüfen Sie den gerade bereitgestellten Code.

Webhook für Ihren Agenten konfigurieren

Jetzt, da der Webhook als Dienst existiert, müssen Sie diesen Webhook 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 vordefinierten Agent 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 an, 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 den Intent 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 ausprobieren

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 Agent 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 ausgegeben werden: Sparkonto oder Girokonto?
3 Wird überprüft Ihr aktuelles Guthaben: 0,00 €

In der Gesprächsrunde Nr. 3 Sie haben „Wird geprüft“ angegeben als Kontotyp auswählen. Der Intent account.balance.check hat einen Parameter namens account. In dieser Unterhaltung ist dieser Parameter auf „checking“ (prüfen) gesetzt. 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. Die Funktion bestimmt den Kontostand. Die Funktion prüft, ob bestimmte Umgebungsvariablen festgelegt sind mit Informationen zum Herstellen einer Verbindung zur Datenbank. Wenn diese Umgebungsvariablen nicht festgelegt sind, Die Funktion verwendet einen hartcodierten Kontostand. 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, versuchen Sie, Logs ansehen für Ihre Funktion.

Weitere Informationen

Weitere Informationen zu den oben genannten Schritten finden Sie hier:

Zurück
Vordefinierten Agent erstellen
Weiter
Datenbank abfragen