Webbapp

  • 5 minuter

Om du vill använda en anpassad hanterare måste du skapa ett webbprogram. När du har skrivit programmet och kompilerat det måste du konfigurera Azure Functions-värden så att den vet hur den ska användas. Vi ska utforska mer om det senare. Först, hur skapar du ett webbprogram i Go?

Skapa ett REST-API i Go

Om du vill skapa ett REST-API med Hjälp av Go behöver du veta några saker:

  • Importera bibliotek. Du använder biblioteken fmt, logoch net/http. De här biblioteken hjälper dig att hantera vägar, hantera inkommande begäranden och hantera loggning. Använd följande importuttryck:

    import (
   "fmt",
   "log",
   "net/http"
)

  • Konfigurera routning. REST-API:er består av logiska divisioner som kallas vägar. Vägar är adresser som svarar på ett specifikt problem i appen. Om du vill konfigurera en väg anropar HandleFunc() du metoden på instansen http och definierar vägen för att svara på begäranden:

    http.HandleFunc("/", handleRoute)

    I det här fallet måste du skapa en handleRoute funktion som matchar inkommande begäranden mot vägen "/".

  • Hantera begäranden. Du måste hantera inkommande begäranden och läsa saker som router eller frågeparametrar eller en publicerad brödtext. Sedan måste du skapa ett svar. En funktion som hanterar en begäran kan se ut så här:

    func handleRequest(w: http:ResponseWriter, r: http.Request) {
    fmt.Fprintf(w, "My first REST API") 
}

    Koden skickar tillbaka texten "Mitt första REST API" till en anropande klient. Metoden Fprintf() tar två argument: svarsströmmen och strängen som ska skickas tillbaka.

  • Skapa servern. För att kunna lyssna på begäranden måste du starta servern. Du måste också ange en del som begäranden kan skickas till. Följande kod visar hur du skapar servern:

    http.ListenAndServe(":3000", nil)

    Servern är nu igång och kan lyssna på begäranden på port 3000.

Skapa en Azure Functions-app

Innan du utvecklar en Azure Functions-app rekommenderar vi att du:

Skapa en Functions-app med hjälp av Visual Studio Code

När du har installerat alla nödvändiga beroenden i systemet är nästa steg att skapa en app. När du tillfrågas om körning väljer du Anpassad hanterare.

Nu har du sett till att rätt filer genereras. När du genererar ett projekt på det här sättet måste du välja en utlösartyp för din första funktion. Anpassade hanterare fungerar med alla vanliga utlösare och bindningar.

När du har genererat projektet bör du ha en app med följande filer:

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

Den function.json filen finns i en katalog vars namn motsvarar det du gav din första funktion namnet. Du använder den här filen för att konfigurera funktionen.

Konfigurera projektet

För att appen ska fungera med HTTP-primitiver måste du konfigurera några saker:

  • Lyssna på en anpassad hanterarport. Din app måste lyssna på en specifik port. Variabeln FUNCTIONS_CUSTOMHANDLER_PORT innehåller det värde som du behöver. Du kan slå upp portvärdet med hjälp av följande kod:

    customHandlerPort, exists := os.LookupEnv("FUNCTIONS_CUSTOMHANDLER_PORT")

  • Konfigurera den körbara standardsökvägen. Eftersom du skapar en körbar fil måste du berätta för functions-appprojektet var den finns.

    Leta upp den function.json filen i projektroten. I avsnittet customHandler anger du defaultExecutablePath. Här är ett exempel på hur det kan se ut:

    "customHandler": {
   "defaultExecutablePath": "mygoapp.exe"
}

  • Aktivera vidarebefordran av begäranden. När du har att göra med en funktion som använder en HTTP-utlösare vill du konfigurera appen något annorlunda än om du hade att göra med en annan typ av utlösare (till exempel en köutlösare).

    Aktivera en egenskap med namnet enableForwardingHttpRequest. När den här egenskapen är aktiverad ändrar den beteendet för hur begäran hanteras på följande sätt:

    • Kopia av den ursprungliga begäran. HTTP-begäran innehåller inte den anpassade hanterarens nyttolast för begäran. I stället anropar Functions-värden hanteraren med en kopia av den ursprungliga HTTP-begäran.

    • Samma sökväg som den ursprungliga begäran. Functions-värden anropar hanteraren med samma sökväg som den ursprungliga begäran.

      När du definierar en väg och en routningshanterare måste du vara specifik för hur du konfigurerar routningen. Anta att du har följande projektdisposition:

      hello/
  function.json

      Filerna i dispositionen mappas som standard till en väg /api/hello . I koden för att konfigurera vägen måste du ange den fullständiga vägen:

      mux.HandleFunc("/api/hello", helloHandler)

      Om du inte hade aktiverat den här inställningen för andra typer av utlösare och bindningar, anger du routerkoden som "/hello" skulle ha varit tillräckligt.

    • Kopia av hanterarens svar. Functions-värden returnerar en kopia av hanterarens HTTP-svar som svar på den ursprungliga begäran.

I föregående exempel är mygoapp.exeden körbara filen . Exemplet förutsätter att du skapar den körbara filen från en fil med namnet mygoapp.go, men du kan ge Go-filen namnet vad du vill. I Linux eller macOS har den körbara filen inget tillägg.

Bygga appen

Att skapa webbappen just nu skiljer sig inte mycket från att skapa en webbapp med hjälp av Go. Så länge du har gjort konfigurationen som beskrivs i föregående avsnitt är du helt inställd.

Nu måste du vidta följande steg:

  1. Läs porten.
  2. Instansiera en HTTP-serverinstans.
  3. Definiera vägar och routningshanterare.
  4. Börja lyssna på porten.
customHandlerPort, exists := os.LookupEnv("FUNCTIONS_CUSTOMHANDLER_PORT")
if !exists {
   customHandlerPort = "8080"
} // 1)
mux := http.NewServeMux() // 2)
mux.HandleFunc("/order", orderHandler) // 3)
fmt.Println("Go server Listening on: ", customHandlerPort)
log.Fatal(http.ListenAndServe(":"+customHandlerPort, mux)) // 4)