Webhook-Dienst erstellen

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

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:

Ihr Dialogflow-Agent und die Funktion müssen sich im selben Projekt befinden. So kann Dialogflow am einfachsten sicher auf Ihre Funktion zugreifen. Wählen Sie vor dem Erstellen der Funktion, wählen Sie Ihr Projekt in der Google Cloud Konsole aus.

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

Zur Übersicht über Cloud Run-Funktionen
Klicken Sie auf Funktion erstellen und legen Sie die Werte für die folgenden Felder fest:
- Umgebung: 1. Generation
- Name der Funktion: tutorial-banking-webhook
- Region: Wenn Sie eine Region für Ihren Agent 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 erforderlich
- HTTPS erforderlich: aktiviert
Klicken Sie auf Speichern.
Klicken Sie auf Weiter (Sie benötigen keine speziellen Laufzeit-, Build-, Verbindungs- oder Sicherheitseinstellungen).
Legen Sie die Werte für die folgenden Felder fest:
- Laufzeit: Wählen Sie die neueste Go-Laufzeit aus.
- Quellcode: Inline-Editor
- Einstiegspunkt: HandleWebhookRequest

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]any `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
	}
}

Klicken Sie auf Bereitstellen.
Warten Sie, bis die Statusanzeige angibt, dass die Funktion erfolgreich bereitgestellt wurde. Sehen Sie sich in der Zwischenzeit den Code an, den Sie gerade bereitgestellt haben.

Webhook für Ihren Agent konfigurieren

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

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

Screenshot: Aktivieren der Auftragsausführung

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

Wählen Sie im Menü der linken Seitenleiste Intents aus.
Wählen Sie den Intent account.balance.check aus.
Scrollen Sie nach unten zum Abschnitt Auftragsausführung.
Webhook-Aufruf für diesen Intent aktivieren einschalten.
Klicken Sie auf Speichern.

Agent ausprobieren

Ihr Agent kann jetzt ausprobiert 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:

Unterhaltungsrunde	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 möchten Sie den Kontostand wissen: Sparkonto oder Girokonto?
3	Girokonto	Ihr aktueller Kontostand: 0,00 $

In Unterhaltungsrunde 3 haben Sie „Girokonto“ als Kontotyp angegeben. Der Intent account.balance.check hat einen Parameter namens account. Dieser Parameter ist in dieser Unterhaltung auf „Girokonto“ festgelegt. Der Intent hat auch einen Aktionswert von „account.balance.check“. Der Webhook-Dienst wird aufgerufen und die Parameter- und Aktionswerte werden an ihn übergeben.

Wenn Sie sich den Webhook-Code oben ansehen, sehen Sie, dass diese Aktion den Aufruf einer ähnlich benannten Funktion auslöst. Die Funktion ermittelt den Kontostand. Die Funktion prüft, ob bestimmte Umgebungsvariablen mit Informationen für die Verbindung zur Datenbank festgelegt sind. Wenn diese Umgebungsvariablen nicht festgelegt sind, verwendet die Funktion einen fest codierten Kontostand. In den nächsten Schritten ändern Sie die Umgebung für die Funktion, damit sie Daten aus einer Datenbank abruft.