Exercício – Usar um manipulador personalizado para criar um aplicativo

3 minutos

Neste exercício, você criará e executará um aplicativo sem servidor usando Go.

Fazer scaffold do aplicativo

Inicie estruturando o app, usando a extensão Azure Functions do Visual Studio Code.

Selecione Exibir>Paleta de Comandos.
Selecione Azure Functions: Criar Novo Projeto.
Selecione uma pasta, geralmente a pasta atual.
Em Selecionar uma linguagem, selecione Manipulador Personalizado.
Em Selecionar um modelo para sua primeira função, selecione HttpTrigger.
Dê um nome ao aplicativo, como hello.
Selecione uma autorização do tipo anônimo. Você poderá alterar isso posteriormente se quiser.

Agora, você tem um projeto que se parece com algo assim:

hello/
  function.json
.funcignore
.gitignore
host.json
local.settings.json
proxies.json

Criar o aplicativo

A próxima série de etapas é sobre a criação de um aplicativo que pode responder a um gatilho HTTP.

Crie um arquivo chamado server.go na raiz do projeto.
Dê ao server.go o seguinte conteúdo:
```
package main

import (
 "fmt"
 "io"
 "log"
 "net/http"
 "os"
)
```
O código anterior importa todas as bibliotecas que você precisa para criar um aplicativo HTTP e procurar variáveis de ambiente.
Adicione o seguinte código após as instruções de importação:
```
func main() {
  customHandlerPort, exists := os.LookupEnv("FUNCTIONS_CUSTOMHANDLER_PORT")
  if !exists {
    customHandlerPort = "8080"
  }
  mux := http.NewServeMux()
  // mux.HandleFunc("/api/hello", helloHandler)
  fmt.Println("Go server Listening on: ", customHandlerPort)
  log.Fatal(http.ListenAndServe(":"+customHandlerPort, mux))
}
```
A função main() é invocada por si só. A primeira linha do código indica como ele lê a partir da FUNCTIONS_CUSTOM_HANDLER_PORT variável de ambiente:
```
customHandlerPort, exists := os.LookupEnv("FUNCTIONS_CUSTOMHANDLER_PORT")
```
Em seguida, a função verifica se a porta existe. Caso não exista, a função é atribuída à porta 8080:
```
if !exists {
  customHandlerPort = "8080"
}
```
O próximo código cria uma instância de servidor HTTP:
```
mux := http.NewServeMux()
```
A última linha de importância é aquela que começa a escutar uma porta específica e sinaliza que está pronta para receber solicitações, com o método ListenAndServe():
```
log.Fatal(http.ListenAndServe(":"+customHandlerPort, mux))
```
Vamos adicionar o código restante. Primeiro, localize a seguinte linha e descompacte-a:
```
// mux.HandleFunc("/api/hello", helloHandler)
```

Entre as instruções de importação e a função main(), adicione o seguinte código:

func helloHandler(w http.ResponseWriter, r *http.Request) {
  w.Header().Set("Content-Type", "application/json")
  if r.Method == "GET" {
    w.Write([]byte("hello world"))
  } else {
    body, _ := io.ReadAll(r.Body)
    w.Write(body)
  }
}

A função helloHandler() define o tipo de conteúdo como application/json. Ele responde com "olá, mundo" ou com o corpo postado, se for o caso.

Executar o aplicativo

Você terminou de criar o código neste ponto, mas ainda precisa fazer algumas configurações para que esse cenário funcione. Você precisa apontar onde está o arquivo executável para que o host do Functions possa encontrá-lo. Você também precisa configurar o roteamento e especificar que este aplicativo lida com gatilhos HTTP e nenhum outro tipo de associações.

Em um terminal, execute go build server.go na raiz do projeto:
```
go build server.go
```
Esta etapa cria um arquivo executável chamado server no macOS e no Linux, ou server.exe em um sistema operacional Windows.
Abra o arquivo host.json e encontre o elemento defaultExecutablePath dentro de customHandler. Especifique ./server no macOS e no Linux, ou .\\server.exe em um sistema operacional Windows.

No elemento customHandler, adicione o elemento enableForwardingHttpRequest e dê a ele o valor true. O elemento customHandler agora deverá ser semelhante a isso:

"customHandler": {
 "description": {
   "defaultExecutablePath": "./server",
   "workingDirectory": "",
   "arguments": []
 },
 "enableForwardingHttpRequest" : true
}

Em um terminal, execute func start na raiz do projeto. Isso iniciará seu aplicativo do Functions.
```
func start
```
No final da saída, você verá uma saída semelhante a:
```
Functions:

     hello: [GET,POST] http://localhost:7071/api/hello
```
Em um navegador, acesse http://localhost:7071/api/hello. Você deverá ver a saída: "olá, mundo".

Parabéns! Você desenvolveu um aplicativo sem servidor em Go.

Comentários

Esta página foi útil?