Anterior

Avançar

Exercício – Manipular uma mensagem da fila

Concluído

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

Observação

Antes de iniciar este exercício, certifique-se de ter feito o download da extensão do Azurite, do Gerenciador de Armazenamento do Azure e do Azure Functions Core Tools.

Fazer scaffold do aplicativo

Para este exercício, vamos começar em um novo aplicativo do Azure Functions. Crie um novo diretório e abra-o.

1. Selecione Exibir>Paleta de Comandos.

2. Selecione Azure Functions: Criar Projeto.

3. Selecione uma pasta, geralmente a pasta atual.

4. Em Selecionar uma linguagem, selecione Manipulador Personalizado.

5. Em Selecionar um modelo para sua primeira função, selecione HttpTrigger.

6. Dê um nome ao aplicativo, como queueTrigger.

7. Selecione um nível de autorização do anônimo. Você poderá alterar o nome posteriormente se quiser.

8. 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 
   

9. Vá para o arquivo function.json no diretório queueTrigger. Encontre a primeira entrada de associação no elemento type:

   {
      "authLevel": "anonymous",
      "type": "httpTrigger",
      "direction": "in",
      "name": "req",
      "methods": [
        "get",
        "post"
      ]
    }
   

   Altere essa entrada de associação para essa configuração:

   {
      "name": "queueItem",
      "type": "queueTrigger",
      "direction": "in",
      "queueName" : "items",
      "connection": "AzureWebJobsStorage"
   }
   

   Nesta etapa, você definirá a propriedade name. Você a consultará mais tarde no código. Você também alterou o tipo de gatilho para queueTrigger, o que possibilita escutar mensagens da fila.

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

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

Criar o aplicativo

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

1. 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.

2. Encontre a seção de importação e adicione os seguintes structs abaixo dela:

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

3. Encontre o método queueHandler() e adicione uma atualização nele 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)
   }
   

   Primeiro, o código 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 própria mensagem é destacada com uma chamada para Unmarshal():

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

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

4. Adicione os códigos a seguir:

   fmt.Println(parsedMessage) // your message
   

   Seu código agora está escrito, mas você precisa configurar seu projeto para poder testá-lo.

5. No arquivo host.json, encontre o elemento defaultExecutablePath e dê a ele um valor ./server.

   Observação

   Para o Windows, você usa o valor .\server.exe.

6. Crie o arquivo server.go executando go build na raiz do projeto:

   go build server.go
   

Configure o ambiente

A próxima etapa é configurar seu ambiente. Como você está desenvolvendo localmente, é necessário defini-lo para que você possa se comunicar com uma fila emulada de mensagens.

1. No arquivo local.settings.json, encontre um elemento em Values chamado AzureWebJobsStorage (ou adicione-o se ele estiver ausente). Dê a ele o valor UseDevelopmentStorage=true. Sua entrada JSON deverá ter essa aparência:

   "AzureWebJobsStorage" : "UseDevelopmentStorage=true"
   

2. Inicie a extensão Azurite abrindo a paleta de comandos (Exibir>Paleta de Comandos) e, em seguida, selecionando Azurite: Iniciar Serviço de Fila.

   Observação

   Esta etapa criará alguns arquivos locais em seu projeto.

3. Abra o Gerenciador de Armazenamento do Azure. No lado esquerdo, os conteúdos do emulador ficam visíveis.

4. Clique com o botão direito do mouse no nó Filas e selecione a opção para criar uma nova fila. Dê a ela o nome items.

   

   Observação

   Você pode nomear a fila como quiser. No entanto, você está prestes a configurar seu arquivo function.json. Seja qual for o nome da fila aqui, será necessário colocá-lo no function.json.

5. Localize o function.json no diretório queueTrigger. Verifique se a matriz bindings tem a seguinte entrada:

   {
      "name": "queueItem",
      "type": "queueTrigger",
      "direction": "in",
      "queueName" : "items",
      "connection": "AzureWebJobsStorage"
    }
   

   A propriedade queueName tem o mesmo nome que a fila que você criou no Gerenciador de Armazenamento do Azure. A propriedade connection aponta para o valor que você configurou em local.settings.json.

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

Executar o aplicativo

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 da fila. Seu código deve ser capaz de consumir essa mensagem.

1. Em um terminal, execute o comando func start na raiz do projeto:

   func start
   

2. No Visual Studio Code, abra a paleta de comandos e execute Azurite: Iniciar Serviço de Fila.

3. Inicie o Gerenciador de Armazenamento do Azure, caso ainda não tenha sido iniciado.

4. No Gerenciador de Armazenamento do Azure, selecione Adicionar Mensagem:

   

5. Na caixa de diálogo exibida, insira a mensagem e selecione OK. Agora você verá os detalhes da mensagem que você criou.

   

6. No Visual Studio Code, sua função agora deve estar em execução. No terminal, agora você deve ver a mensagem impressa como a última linha.

   Sua função conseguiu consumir a mensagem da fila e gravar seu conteúdo.

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

O que você faz com uma mensagem de entrada cabe a você. Por exemplo, você pode armazená-la em um banco de dados, ou talvez enviá-la como conteúdo em uma solicitação da Web.

Continuar