Webhook-Dienst erstellen

Der vordefinierte Agent, den Sie im letzten Schritt erstellt haben, kann keine dynamischen Daten wie Kontostände bereitstellen, da alles im Agent hartcodiert ist. In diesem Schritt der Anleitung erstellen Sie einen Webhook, der dem Agent dynamische Daten zur Verfügung stellen kann. Der Einfachheit halber wird der Webhook in dieser Anleitung mit Cloud Functions gehostet. Es gibt jedoch noch viele andere Möglichkeiten, einen Webhook-Dienst zu hosten. In diesem Beispiel wird auch die Programmiersprache Go verwendet. Sie können jedoch jede von Cloud Functions unterstützte Sprache verwenden.

Funktion erstellen

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

  1. Der Dialogflow-Agent und die Funktion müssen sich im selben Projekt befinden. Dies ist die einfachste Möglichkeit für Dialogflow, einen sicheren Zugriff auf die Funktion zu erhalten. Wählen Sie vor dem Erstellen der Funktion Ihr Projekt in der Google Cloud Console aus.

    Zur Projektauswahl

  2. Öffnen Sie die Übersichtsseite zu Cloud Functions.

    Zur Cloud Functions-Übersicht

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

    • Umgebung: 1. Generation
    • Funktionsname: 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 zum Kopieren und speichern Sie den Wert. Sie benötigen diese URL zum Konfigurieren des Webhooks.
    • Authentifizierung: Authentifizierung erforderlich
    • Require HTTPS (HTTPS erforderlich): aktiviert

  4. Klicken Sie auf Speichern.

  5. Klicken Sie auf Weiter. Sie benötigen keine spezielle Laufzeit, keinen Build, keine Verbindungen 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, sehen Sie sich den gerade bereitgestellten Code an.

Webhook für Ihren Agent konfigurieren

Nachdem der Webhook nun als Dienst vorhanden ist, müssen Sie ihn mit Ihrem Agent verknüpfen. Dies erfolgt ü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

Nun, da die Auftragsausführung für den Agent aktiviert ist, 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 Auftragsausführung.
  4. Webhook-Aufruf für diesen Intent aktivieren einschalten.
  5. Klicken Sie auf Speichern.

Agent ausprobieren

Der 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 Sie Agent
1 Guten Tag, 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öchtest du den Kontostand: Spar- oder Girokonto?
3 Wird überprüft Hier ist dein aktueller Kontostand: 0,00 $

In Unterhaltungsrunde 3 haben Sie als Kontotyp „Prüfen“ angegeben. Der Intent account.balance.check hat einen Parameter namens account. Dieser Parameter ist in dieser Unterhaltung auf „checking“ gesetzt. Der Intent hat außerdem den Aktionswert „account.balance.check“. Der Webhook-Dienst wird aufgerufen und ihm werden die Parameter- und Aktionswerte übergeben.

Wenn Sie den obigen Webhook-Code prüfen, stellen Sie fest, dass diese Aktion den Aufruf einer ähnlich benannten Funktion auslöst. Die Funktion bestimmt den Kontostand. Die Funktion prüft, ob bestimmte Umgebungsvariablen mit Informationen zum Herstellen einer Verbindung zur Datenbank festgelegt sind. Wenn diese Umgebungsvariablen nicht festgelegt sind, verwendet die Funktion einen hartcodierten Kontostand. In den nächsten Schritten ändern Sie die Umgebung für die Funktion so, dass Daten aus einer Datenbank abgerufen werden.

Fehlerbehebung

Der Webhook-Code enthält Logging-Anweisungen. Wenn Probleme auftreten, können Sie versuchen, die Logs für Ihre Funktion aufzurufen.

Weitere Informationen

Weitere Informationen zu den oben genannten Schritten finden Sie hier:

Zurück
Vordefinierten Agent erstellen
Weiter
Datenbank abfragen