Oefening: een aangepaste handler gebruiken om een app te bouwen

3 minuten

In deze oefening bouwt en voert u een serverloze app uit met behulp van Go.

Scaffold de app

Begin met het opzetten van de app met behulp van de Azure Functions-extensie in Visual Studio Code.

Selecteer .
Selecteer Azure Functions: Nieuw project maken.
Selecteer een map, meestal uw huidige map.
Selecteer aangepaste handler in Een taal selecteren.
Selecteer HttpTrigger in Selecteer een sjabloon voor uw eerste functie.
Geef de app een naam, zoals hallo.
Selecteer een autorisatieniveau van anoniem. U kunt dit later desgewenst wijzigen.

U hebt nu een project dat er ongeveer als volgt uitziet:

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

De app maken

De volgende reeks stappen gaat over het maken van een app die kan reageren op een HTTP-trigger.

Maak een bestand met de naam server.go in de hoofdmap van het project.
Geef server.go de volgende inhoud:
```
package main

import (
 "fmt"
 "io"
 "log"
 "net/http"
 "os"
)
```
Met de voorgaande code worden alle bibliotheken geïmporteerd die u nodig hebt om een HTTP-app te bouwen en omgevingsvariabelen op te zoeken.
Voeg de volgende code toe na de importinstructies:
```
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))
}
```
De main() functie wordt zelf aangeroepen. De eerste regel van de code geeft aan hoe deze wordt gelezen uit de FUNCTIONS_CUSTOM_HANDLER_PORT omgevingsvariabele:
```
customHandlerPort, exists := os.LookupEnv("FUNCTIONS_CUSTOMHANDLER_PORT")
```
Vervolgens controleert de functie of de poort bestaat. Zo niet, dan krijgt de functie poort 8080 toegewezen:
```
if !exists {
  customHandlerPort = "8080"
}
```
Met de volgende code wordt een HTTP-serverexemplaren geïnstitueert:
```
mux := http.NewServeMux()
```
De laatste regel van belang is degene die begint te luisteren naar een specifieke poort en signalen geeft aan dat het klaar is voor het ontvangen van aanvragen, met de methode ListenAndServe():
```
log.Fatal(http.ListenAndServe(":"+customHandlerPort, mux))
```
Laten we de resterende code toevoegen. Zoek eerst de volgende regel en verwijder de opmerking:
```
// mux.HandleFunc("/api/hello", helloHandler)
```

Voeg tussen de importinstructies en de main() functie de volgende code toe:

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

Met de helloHandler() functie wordt het inhoudstype ingesteld op application/json. Het reageert met 'hallo wereld' of de geplaatste hoofdtekst, indien van toepassing.

De app uitvoeren

U bent klaar met het ontwerpen van de code op dit moment, maar u moet een configuratie uitvoeren om dit scenario te laten werken. U moet aangeven waar het uitvoerbare bestand zich bevindt, zodat de functiehost het kan vinden. U moet ook de routering en status configureren die deze app behandelt met HTTP-triggers en geen andere typen bindingen.

Voer vanuit een terminal de volgende opdracht uit go build server.go in de hoofdmap van het project:
```
go build server.go
```
Met deze stap maakt u een uitvoerbaar bestand dat server wordt genoemd in macOS en Linux, of server.exe op een Windows-besturingssysteem.
Open het host.json-bestand en zoek het defaultExecutablePath element in het customHandler bestand. Geef ./server op macOS en Linux of .\\server.exe op een Windows-besturingssysteem op.

Voeg onder het customHandler element het enableForwardingHttpRequest element toe en geef het de waarde true. Uw customHandler element moet er nu als volgt uitzien:

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

Voer func start vanuit een terminal uit in de hoofdmap van het project. Als u dit doet, wordt uw Functions-app gestart.
```
func start
```
Aan het einde van de uitvoer ziet u een uitvoer die vergelijkbaar is met:
```
Functions:

     hello: [GET,POST] http://localhost:7071/api/hello
```
Ga in een browser naar http://localhost:7071/api/hello. Als het goed is, ziet u de uitvoer 'hallo wereld'.

Gefeliciteerd U hebt een serverloze app in Go ontwikkeld.

Feedback

Is deze pagina nuttig?