Exercício - Manipular uma mensagem de fila

5 minutos

Neste exercício, você estenderá seu aplicativo com uma rota que pode ser acionada em uma mensagem em uma fila de mensagens.

Nota

Antes de iniciar este exercício, certifique-se de que baixou a extensão Azurite, baixou o Gerenciador de Armazenamento do Azure e baixou as Ferramentas Principais do Azure Functions.

Andaime o aplicativo

Para este exercício, começaremos em um novo aplicativo do Azure Functions. Crie um novo diretório e coloque-se nele.

Selecione Exibir>paleta de comandos.
Selecione Azure Functions: Create New Project.
Selecione uma pasta, geralmente a pasta atual.
Em Selecione um idioma, selecione Manipulador personalizado.
Em Selecione um modelo para sua primeira função, selecione HttpTrigger.
Dê um nome ao aplicativo, como queueTrigger.
Selecione um nível de autorização de anônimo. Você pode alterar isso mais tarde, se desejar.

Na raiz, crie um arquivo chamado server.go. Seu projeto agora deve ter os seguintes arquivos:

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

Vá para o arquivo function.json no queueTrigger diretório. Encontre a primeira entrada de vinculação no type elemento :
```
{
   "authLevel": "anonymous",
   "type": "httpTrigger",
   "direction": "in",
   "name": "req",
   "methods": [
     "get",
     "post"
   ]
 }
```
Altere essa entrada de vinculação para esta configuração:
```
{
   "name": "queueItem",
   "type": "queueTrigger",
   "direction": "in",
   "queueName" : "items",
   "connection": "AzureWebJobsStorage"
}
```
Nesta etapa, você define a name propriedade. Você se referirá a ele mais tarde no código. Você também alterou o tipo de gatilho para queueTrigger, o que torna possível ouvir mensagens de fila.

O queueName valor aponta para uma fila específica. Quando você executar o emulador mais tarde, você criará uma fila com esse nome.

Finalmente, você apontou uma variável no local.settings.json que conterá a cadeia de conexão para a fila.

Criar a aplicação

Neste ponto, você tem um esqueleto de aplicativo. Agora você está pronto para adicionar código que pode lidar com mensagens de fila de entrada.

Abra o arquivo server.go e adicione o seguinte código:

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))
}

Agora você tem uma rota configurada em /queueTrigger.

Encontre a seção de importação e adicione as seguintes estruturas sob ela:

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

Encontre o queueHandler() método e adicione atualizá-lo da seguinte maneira:

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)
}

O código primeiro lê o corpo do fluxo de resposta de entrada e o decodifica:

var invokeRequest InvokeRequest

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

Em seguida, a mensagem em si é escavada com uma chamada para Unmarshal():

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

Agora que você tem a mensagem, vamos imprimi-la.

Adicione o seguinte código:
```
fmt.Println(parsedMessage) // your message
```
Seu código agora está todo escrito, mas você precisa configurar seu projeto para poder testá-lo.
No arquivo host.json, localize o defaultExecutablePath elemento e atribua-lhe um valor de ./server.

Nota

Para Windows, você usaria um valor de .\server.exe.
Crie o arquivo server.go executando go build na raiz do projeto:
```
go build server.go
```

Configurar o ambiente

A próxima etapa é configurar seu ambiente. Como você está desenvolvendo localmente, precisa configurá-lo para que possa falar com uma fila de mensagens emuladas.

No arquivo local.settings.json, localize um elemento em Values chamado AzureWebJobsStorage (ou adicione-o se estiver faltando). Dê-lhe o valor UseDevelopmentStorage=true. Sua entrada JSON deve ter esta aparência:
```
"AzureWebJobsStorage" : "UseDevelopmentStorage=true"
```
Inicie a extensão Azurite abrindo a paleta de comandos (Exibir>paleta de comandos) e selecionando Azurite: Iniciar serviço de fila.

Nota

Esta etapa criará alguns arquivos locais em seu projeto.
Abra o Gerenciador de Armazenamento do Azure. No lado esquerdo, o conteúdo do emulador é visível.
Clique com o botão direito do mouse no nó Filas e selecione a opção para criar uma nova fila. Dê-lhe os itens de nome.

Nota

Você pode nomear a fila como quiser. No entanto, você está prestes a configurar seu arquivo function.json . Seja qual for o nome, a fila aqui precisa entrar em function.json.
Localize function.json sob o queueTrigger diretório. Verifique se a bindings matriz tem a seguinte entrada:
```
{
   "name": "queueItem",
   "type": "queueTrigger",
   "direction": "in",
   "queueName" : "items",
   "connection": "AzureWebJobsStorage"
 }
```
A queueName propriedade tem o mesmo nome da fila que você criou no Gerenciador de Armazenamento do Azure. A connection propriedade aponta para o valor que você configurou no local.settings.json.

A name propriedade tem o valor queueItem. Seu código Go usa esse valor para analisar a mensagem da fila.

Executar a aplicação

Neste ponto, tudo está configurado. Tudo o que você precisa fazer é executar o aplicativo, iniciar o Gerenciador de Armazenamento do Azure e criar uma mensagem de fila. Seu código deve ser capaz de consumir essa mensagem.

A partir de um terminal, execute o func start comando na raiz do projeto:
```
func start
```
No Visual Studio Code, abra a paleta de comandos e execute Azurite: Start Queue Service.
Inicie o Gerenciador de Armazenamento do Azure, se ainda não tiver sido iniciado.
No Gerenciador de Armazenamento do Azure, selecione Adicionar mensagem:
Na caixa de diálogo exibida, digite a mensagem e selecione OK. Agora você vê os detalhes da mensagem que você criou.
No Visual Studio Code, sua função agora deve estar em execução. No terminal, você deve ver a mensagem impressa como a última linha.

Sua função foi capaz de consumir a mensagem de fila e escrever seu conteúdo.

Parabéns! Você criou uma função do Azure em Go que pode ser acionada em uma mensagem de fila. Você também analisou essa mensagem.

O que você faz com uma mensagem recebida depende de você. Por exemplo, você pode armazená-lo em um banco de dados ou talvez enviá-lo como a carga útil em uma solicitação da Web.

Exercício - Manipular uma mensagem de fila

Andaime o aplicativo

Criar a aplicação

Configurar o ambiente

Executar a aplicação

Comentários