Ejercicio: Control de un mensaje de cola

5 minutos

En este ejercicio, extenderá la aplicación con una ruta que se pueda desencadenar en un mensaje en una cola de mensajes.

Nota:

Antes de comenzar este ejercicio, asegúrese de que ha descargado la extensión de Azurite, el Explorador de Azure Storage y Azure Functions Core Tools.

Scaffolding de la aplicación

En este ejercicio, comenzaremos con una nueva aplicación de Azure Functions. Cree un directorio e inclúyase en este.

Seleccione Ver>Paleta de comandos.
Seleccione Azure Functions: Crear proyecto.
Seleccione una carpeta, normalmente la carpeta actual.
En Seleccionar un idioma, elija Controlador personalizado.
En Select a template for your first function (Seleccionar una plantilla para la primera función), seleccione HttpTrigger.
Asigne un nombre a la aplicación, como queueTrigger.
Seleccione el nivel de autorización anónimo. Si quiere, puede cambiar el nombre posteriormente.

En la raíz, cree un archivo denominado server.go. El proyecto debe tener los siguientes archivos:

queueTrigger/
  function.json
.funcignore
.gitignore
host.json
local.settings.json
proxies.json
server.go

Vaya al archivo function.json en el directorio queueTrigger. Busque la primera entrada de enlace en el elemento type:
```
{
   "authLevel": "anonymous",
   "type": "httpTrigger",
   "direction": "in",
   "name": "req",
   "methods": [
     "get",
     "post"
   ]
 }
```
Cambie esa entrada de enlace a esta configuración:
```
{
   "name": "queueItem",
   "type": "queueTrigger",
   "direction": "in",
   "queueName" : "items",
   "connection": "AzureWebJobsStorage"
}
```
En este paso, se establece la propiedad name. Hará referencia a esta más adelante en el código. También ha cambiado el tipo de desencadenador a queueTrigger, lo que permite escuchar los mensajes de cola.

El valor queueName apunta a una cola específica. Cuando ejecute el emulador más adelante, creará una cola con este nombre.

Por último, ha indicado una variable en local.settings.json que contendrá la cadena de conexión para la cola.

Creación de la aplicación

En este momento, tiene un esqueleto de aplicación. Ya está listo para agregar código que pueda controlar los mensajes de cola entrantes.

Abra el archivo server.go y agregue el código siguiente:

package main

import (
  "encoding/json",
  "fmt"
  "io/ioutil"
  "log"
  "net/http"
  "os"
)

func queueHandler(w http.ResponseWriter, r *http.Request) {
}

func main() {
  customHandlerPort, exists := os.LookupEnv("FUNCTIONS_CUSTOMHANDLER_PORT")
  if !exists {
    customHandlerPort = "8080"
  }
  mux := http.NewServeMux()
  mux.HandleFunc("/queueTrigger", queueHandler)
  fmt.Println("Go server Listening on: ", customHandlerPort)
  log.Fatal(http.ListenAndServe(":"+customHandlerPort, mux))
}

Ahora tiene una ruta configurada en /queueTrigger.

Busque la sección import y agregue los siguientes structs en esta:

type InvokeRequest struct {
  Data     map[string]json.RawMessage
  Metadata map[string]interface{}
}

Busque el método queueHandler() y actualícelo de la siguiente manera:

func queueHandler(w http.ResponseWriter, r *http.Request) {
  var invokeRequest InvokeRequest

  d := json.NewDecoder(r.Body)
  d.Decode(&invokeRequest)

  var parsedMessage string
  json.Unmarshal(invokeRequest.Data["queueItem"], &parsedMessage)
}

El código primero lee el cuerpo del flujo de respuesta entrante y lo descodifica:

var invokeRequest InvokeRequest

d := json.NewDecoder(r.Body)
d.Decode(&invokeRequest)

A continuación, el propio mensaje se pone al día con una llamada a Unmarshal():

var parsedMessage string
json.Unmarshal(invokeRequest.Data["queueItem"], &parsedMessage)

Ahora que tiene el mensaje, vamos a imprimirlo.

Agregue el código siguiente:
```
fmt.Println(parsedMessage) // your message
```
El código ya está todo escrito, pero debe configurar el proyecto para poder probarlo.
En el archivo host.json, busque el elemento defaultExecutablePath y asígnele un valor de ./server.

Nota:

Para Windows, usaría un valor de .\server.exe.
Compile el archivo server.go mediante la ejecución de go build en la raíz del proyecto:
```
go build server.go
```

Configuración del entorno

El siguiente paso es configurar el entorno. Dado que está desarrollando localmente, debe configurarlo para poder hablar con una cola de mensajes emulada.

En el archivo local.settings.json, busque un elemento en Values denominado AzureWebJobsStorage (o agréguelo si falta). Asígnele el valor UseDevelopmentStorage=true. La entrada JSON debe ser similar a esta:
```
"AzureWebJobsStorage" : "UseDevelopmentStorage=true"
```
Para iniciar la extensión Azurite, abra la paleta de comandos (Ver>Paleta de comandos) y seleccione Azurite: Start Queue Service (Azurite: Iniciar Queue service).

Nota:

Este paso creará algunos archivos locales en el proyecto.
Abra el Explorador de Azure Storage. En el lado izquierdo, el contenido del emulador es visible.
Haga clic con el botón derecho en el nodo Colas y seleccione la opción para crear una nueva cola. Asígnele el nombre elementos.

Nota:

Puede asignar a la cola el nombre que desee. Sin embargo, está a punto de configurar el archivo function.json. El nombre que asigne aquí a la cola debe incluirse en el archivo function.json.
Busque function.json en el directorio queueTrigger. Asegúrese de que la matriz bindings tiene la entrada siguiente:
```
{
   "name": "queueItem",
   "type": "queueTrigger",
   "direction": "in",
   "queueName" : "items",
   "connection": "AzureWebJobsStorage"
 }
```
La propiedad queueName tiene el mismo nombre que la cola que creó en el Explorador de Azure Storage. La propiedad connection apunta al valor que configuró enlocal.settings.json.

La propiedad name tiene el valor queueItem. El código de Go usa este valor para analizar el mensaje de cola.

Ejecución la aplicación

Llegado este punto, todo está configurado. Todo lo que debe hacer es ejecutar la aplicación, iniciar el Explorador de Azure Storage y crear un mensaje de cola. El código debe poder consumir ese mensaje.

Desde un terminal, ejecute el comando func start en la raíz del proyecto:
```
func start
```
En Visual Studio Code, abra la paleta de comandos y ejecute Azurite: Start Queue Service (Azurite: Iniciar Queue service).
Inicie el Explorador de Azure Storage si aún no se ha iniciado.
En el Explorador de Azure Storage, seleccione Agregar mensaje:
En el cuadro de diálogo que aparece, escriba mensaje y seleccione Aceptar. Ahora puede ver los detalles del mensaje que ha creado.
En Visual Studio Code, la función debería estar en ejecución. En el terminal, ahora debería ver mensaje impreso como la última fila.

La función pudo consumir el mensaje de cola y escribir su contenido.

¡Enhorabuena! Ha creado una función de Azure en Go que se puede desencadenar en un mensaje de cola. También ha analizado ese mensaje.

Lo que haga con un mensaje entrante es decisión suya. Por ejemplo, puede almacenarlo en una base de datos o quizás enviarlo como carga útil en una solicitud web.

Continuar

Ejercicio: Control de un mensaje de cola

Scaffolding de la aplicación

Creación de la aplicación

Configuración del entorno

Ejecución la aplicación

Comentarios