Crea un servicio de webhook

El agente compilado previamente que creaste en el último paso no pueden proporcionar datos dinámicos, como saldos de cuentas, porque todo está codificado en el agente. En este paso del instructivo, crearás un webhook que puede proporcionar datos dinámicos al agente. Funciones de Cloud Run para alojar el webhook en este instructivo, debido a su simplicidad pero hay muchas otras formas de alojar un servicio de webhook. En el ejemplo, también se usa el lenguaje de programación Go, pero puedes usar cualquier lenguaje compatible con las funciones de Cloud Run.

Crea la función

Las funciones de Cloud Run pueden crearse con la consola de Google Cloud (consulta la documentación, abre la consola). Sigue estos pasos para crear una función en este instructivo:

  1. Es importante que tu agente de Dialogflow y la función están en el mismo proyecto. Esta es la forma más fácil de que Dialogflow acceso seguro a tu función. Antes de crear la función, selecciona tu proyecto en la consola de Google Cloud.

    Ir al selector de proyectos

  2. Abre la página de descripción general de las funciones de Cloud Run.

    Ir a la descripción general de las funciones de Cloud Run

  3. Haz clic en Crear función y configura los siguientes campos:

    • Entorno: 1a gen.
    • Nombre de la función: tutorial-banking-webhook
    • Región: si especificaste una región para el agente, usan la misma región.
    • Tipo de activador HTTP: HTTP
    • URL: Haz clic en el botón Copiar aquí y guarda el valor. Necesitarás esta URL cuando configures el webhook.
    • Autenticación: requiere autenticación
    • Solicitar HTTPS: marcado

  4. Haz clic en Guardar.

  5. Haz clic en Next (No necesitas funciones especiales de entorno de ejecución, compilación, conexiones o parámetros de configuración de seguridad).

  6. Configura los siguientes campos:

    • Entorno de ejecución: Selecciona el entorno de ejecución de Go más reciente.
    • Código fuente: Editor intercalado
    • Punto de entrada: HandleWebhookRequest

  7. Reemplaza el código por lo siguiente: 

    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. Haz clic en Implementar.

  9. Espera hasta que el indicador de estado muestre que la función se implementó correctamente. Mientras esperas, examina el código que acabas de implementar.

Configura el webhook para tu agente

Ahora que el webhook existe como servicio debes asociar este webhook a tu agente. Esto se hace a través de la entrega. A fin de habilitar y administrar la entrega para tu agente, sigue estos pasos:

  1. Ve a la consola de Dialogflow ES.
  2. Selecciona el agente compilado previamente que acabas de crear.
  3. Selecciona Entrega en el menú de la barra lateral izquierda.
  4. Con el botón para activar o desactivar, selecciona Enabled (Habilitado) en el campo Webhook.
  5. Proporciona la URL que copiaste de arriba. Deja todos los otros campos en blanco.
  6. Haz clic en Guardar en la parte inferior de la página.

Captura de pantalla de la habilitación de la entrega.

Ahora que la entrega está habilitada para el agente, necesitas habilitar la entrega para un intent:

  1. En el menú de la barra lateral izquierda, selecciona Intents.
  2. Selecciona el intent account.balance.check.
  3. Desplázate hacia abajo hasta la sección Entrega.
  4. Activa la opción Enable webhook call for this intent.
  5. Haz clic en Guardar.

Probar el agente

Tu agente ya está listo para probarlo. Haz clic en el botón Probar agente para abrir el simulador. Intenta tener la siguiente conversación con el agente:

Turno de conversación Tú Agente
1 Hola Hola. Gracias por elegir ACME Bank.
2 Quiero conocer el saldo de mi cuenta ¿Para qué cuenta quieres el saldo: cuenta corriente o caja de ahorro?
3 En verificación Este es tu saldo más reciente: USD 0.00

En el tercer turno de conversación, suministraste la “verificación” como el tipo de cuenta. El intent account.balance.check tiene un parámetro que se denomina account. Este parámetro se estableció en "checking" en esta conversación. El intent también tiene un valor de acción de "account.balance.check". Se llama al servicio de webhook y se le pasan los valores del parámetro y de la acción.

Si examinas el código de webhook anterior, verás que esta acción activa una función con nombre similar a la que se llamará. La función determina el saldo de la cuenta. La función verifica si se configuraron variables de entorno específicas con información para conectarse a la base de datos. Si estas variables de entorno no están configuradas, la función usa un saldo de cuenta codificado. En los próximos pasos, alterarás el entorno para la función para recuperar datos de una base de datos.

Soluciona problemas

El código de webhook incluye instrucciones de registro. Si tienes problemas, prueba visualiza los registros para tu función.

Más información

Para obtener más información sobre los pasos anteriores, consulta:

Anterior
Crea un agente compilado previamente
Siguiente
Consultar una base de datos