Aplicação Web

5 minutos

Para usar um manipulador personalizado, você precisa criar um aplicativo Web. Depois de escrever seu aplicativo e compilá-lo, você precisa configurar o host do Azure Functions para que ele saiba como usá-lo. Exploraremos mais sobre isso mais tarde. Primeiro, como você cria um aplicativo Web no Go?

Crie uma API REST em Go

Para criar uma API REST usando o Go, você precisa saber algumas coisas:

Importar bibliotecas. Você usará as bibliotecas fmt, log, e net/http. Essas bibliotecas ajudarão você a gerenciar rotas, lidar com solicitações de entrada e lidar com registros. Use a seguinte instrução de importação:
```
import (
   "fmt",
   "log",
   "net/http"
)    
```
Configure o roteamento. As APIs REST consistem em divisões lógicas chamadas rotas. Rotas são endereços que respondem a uma preocupação específica no aplicativo. Para configurar uma rota, chame o HandleFunc() método na http instância e defina a rota para responder às solicitações:
```
http.HandleFunc("/", handleRoute)   
```
Nesse caso, você precisa criar uma handleRoute função para corresponder as solicitações de entrada com a rota "/".
Gerencie solicitações. Você precisa gerenciar solicitações de entrada e ler coisas como parâmetros de roteador ou consulta ou um corpo postado. Então você precisa construir uma resposta. Uma função que lida com uma solicitação pode ter esta aparência:
```
func handleRequest(w: http:ResponseWriter, r: http.Request) {
    fmt.Fprintf(w, "My first REST API") 
}
```
O código envia o texto "Minha primeira API REST" de volta para um cliente de chamada. O método Fprintf() usa dois argumentos: o fluxo de resposta e a cadeia de caracteres para enviar de volta.
Crie o servidor. Para ser capaz de ouvir as solicitações, você precisa iniciar o servidor. Você também precisa especificar uma parte para a qual as solicitações podem ser enviadas. O código a seguir mostra como criar o servidor:
```
http.ListenAndServe(":3000", nil)
```
O servidor está agora ativo e pode ouvir as solicitações na porta 3000.

Criar uma aplicação de funções das Funções do Azure

Antes de desenvolver um aplicativo do Azure Functions, recomendamos que:

Instale o Visual Studio Code. Você pode criar aplicativos do Azure Functions com qualquer editor de texto ou IDE. Este módulo apresenta algumas extensões que facilitam a criação.
Instale a extensão de código do Visual Studio para o Azure Functions. Esta extensão irá ajudá-lo a criar um aplicativo Functions, executá-lo e depurá-lo.
Instale as Ferramentas Principais do Azure Functions. Esta instalação inclui um func comando executável que lhe permite executar a sua aplicação Functions, entre outras coisas.

Andaime um aplicativo Functions usando o Visual Studio Code

Depois de ter todas as dependências necessárias instaladas no seu sistema, o próximo passo é criar um aplicativo. Quando for perguntado sobre o tempo de execução, escolha Manipulador personalizado.

Agora você garantiu que os arquivos corretos serão gerados. Quando você gera um projeto dessa forma, você precisa selecionar um tipo de gatilho para sua primeira função. Os manipuladores personalizados trabalham com todos os gatilhos e ligações usuais.

Depois de terminar de gerar o projeto, você deve ter um aplicativo com os seguintes arquivos:

host.json
local.setting.json
proxies.json
function.json

O arquivo function.json está em um diretório cujo nome corresponde ao que você nomeou sua primeira função. Você usará esse arquivo para configurar sua função.

Configurar o projeto

Para que seu aplicativo funcione com primitivas HTTP, você precisa configurar algumas coisas:

Ouça uma porta de manipulador personalizada. Seu aplicativo precisa ouvir uma porta específica. A variável FUNCTIONS_CUSTOMHANDLER_PORT contém o valor que você precisa. Você pode procurar o valor da porta usando o seguinte código:
```
customHandlerPort, exists := os.LookupEnv("FUNCTIONS_CUSTOMHANDLER_PORT")
```
Configure o caminho executável padrão. Como você está criando um arquivo executável, precisa informar ao seu projeto do aplicativo Functions onde ele está localizado.

Localize o arquivo function.json na raiz do projeto. customHandler Na seção , especifique defaultExecutablePath. Aqui está um exemplo de como ele pode parecer:
```
"customHandler": {
   "defaultExecutablePath": "mygoapp.exe"
}
```
Habilite o encaminhamento de solicitações. Ao lidar com uma função que usa um gatilho HTTP, você deseja configurar o aplicativo de forma ligeiramente diferente do que se estivesse lidando com outro tipo de gatilho (como um gatilho de fila).

Habilite uma propriedade chamada enableForwardingHttpRequest. Quando essa propriedade é habilitada, ela altera o comportamento de como a solicitação é tratada das seguintes maneiras:
- Cópia do pedido original. A solicitação HTTP não contém a carga útil da solicitação do manipulador personalizado. Em vez disso, o host Functions invoca o manipulador com uma cópia da solicitação HTTP original.
- Mesmo caminho da solicitação original. O host Functions invoca o manipulador com o mesmo caminho da solicitação original.
  
  Ao definir uma rota e um manipulador de rotas, você precisa ser específico em como configurar o roteamento. Digamos que você tenha o seguinte esboço de projeto:
```
hello/
  function.json   
```
  Os arquivos na estrutura de tópicos serão mapeados para uma rota /api/hello por padrão. No seu código para configurar a rota, você precisa especificar a rota completa:
```
mux.HandleFunc("/api/hello", helloHandler)
```
  Se você não tivesse habilitado essa configuração, para outros tipos de gatilhos e associações, especificar o código do roteador como "/hello" teria sido suficiente.
- Cópia da resposta do manipulador. O host Functions retorna uma cópia da resposta HTTP do manipulador como a resposta à solicitação original.

No exemplo anterior, o arquivo executável é mygoapp.exe. O exemplo pressupõe que você esteja criando o arquivo executável a partir de um arquivo chamado mygoapp.go, mas você pode nomear seu arquivo Go como quiser. No Linux ou macOS, o arquivo executável não tem uma extensão.

Criar a aplicação

Criar o aplicativo Web neste momento não é muito diferente de criar qualquer aplicativo Web usando Go. Desde que você tenha feito a configuração descrita na seção anterior, você está pronto.

Agora você precisa seguir os seguintes passos:

Leia a porta.
Instancie uma instância do servidor HTTP.
Defina rotas e manipuladores de rotas.
Comece a ouvir na porta.