Webalkalmazás

  • 5 perc

Egyéni kezelő használatához webalkalmazást kell létrehoznia. Miután megírta és lefordította az alkalmazást, konfigurálnia kell az Azure Functions-gazdagépet, hogy tudja, hogyan kell használni. Erről később részletesebben is megismerkedünk. Először is, hogyan hozhat létre webalkalmazást a Go-ban?

REST API létrehozása a Go-ban

A REST API Go használatával történő létrehozásához ismernie kell néhány dolgot:

  • Könyvtárak importálása. A kódtárakat fmtlognet/httpés a . Ezek a kódtárak segítenek kezelni az útvonalakat, kezelni a bejövő kéréseket, és kezelni a naplózást. Használja a következő importálási utasítást:

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

  • Útvonalirányítás beállítása. A REST API-k útvonalaknak nevezett logikai osztásokból állnak. Az útvonalak olyan címek, amelyek egy adott problémára reagálnak az alkalmazásban. Útvonal beállításához hívja meg a HandleFunc() példány metódusát http , és határozza meg a kérésekre válaszoló útvonalat:

    http.HandleFunc("/", handleRoute)

    Ebben az esetben létre kell hoznia egy függvényt handleRoute , amely megfelel a bejövő kéréseknek az útvonalon "/".

  • Kérelmek kezelése. Kezelnie kell a bejövő kéréseket, és be kell olvasnia olyan dolgokat, mint az útvonalparamétereket, a lekérdezési paramétereket, valamint a beküldött törzset. Ezután létre kell hoznunk egy választ. A kéréseket kezelő függvények a következőképpen nézhetnek ki:

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

    A kód visszaküldi a "Saját első REST API" szöveget egy hívó ügyfélnek. A metódus Fprintf() két argumentumot használ: a válaszfolyamot és a sztringet a visszaküldéshez.

  • Hozza létre a kiszolgálót. A kérések figyeléséhez el kell indítania a kiszolgálót. Meg kell adnia egy olyan részt is, amelybe a kérések elküldhetők. A következő kód bemutatja, hogyan hozhatja létre a kiszolgálót:

    http.ListenAndServe(":3000", nil)

    A kiszolgáló most már működik, és meghallgathatja a kéréseket a 3000-s porton.

Az Azure Functions alkalmazás létrehozása

Az Azure Functions-alkalmazások fejlesztése előtt a következőket javasoljuk:

  • Telepítse a Visual Studio Code-ot. Az Azure Functions-alkalmazásokat bármilyen szövegszerkesztővel vagy IDE-vel létrehozhatja. Ez a modul néhány olyan bővítményt mutat be, amelyek megkönnyítik a szerkesztést.

  • Telepítse az Azure Functions Visual Studio Code-bővítményét. Ez a bővítmény segít a Functions-alkalmazások létrehozásában, futtatásában és hibakeresésében.

  • Telepítse az Azure Functions Core Toolst. Ez a telepítés tartalmaz egy func végrehajtható parancsot, amely többek között lehetővé teszi a Functions-alkalmazás futtatását.

Függvényalkalmazás vázának létrehozása a Visual Studio Code használatával

Miután telepítette az összes szükséges függőséget a rendszeren, a következő lépés egy alkalmazás létrehozása. Amikor a futási környezetről kérdezik, válassza a Egyéni kezelőt.

Most már meggyőződett arról, hogy a megfelelő fájlok lesznek létrehozva. Ha így hoz létre projektet, ki kell választania egy triggertípust az első függvényhez. Az egyéni kezelők az összes szokásos eseményindítóval és kötéssel dolgoznak.

A projekt létrehozása után rendelkeznie kell egy alkalmazással a következő fájlokkal:

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

A function.json fájl egy olyan könyvtárban található, amelynek a neve megegyezik az első függvény nevével. Ezzel a fájllal konfigurálhatja a függvényt.

A projekt konfigurálása

Ahhoz, hogy az alkalmazás HTTP-primitívekkel működjön, konfigurálnia kell néhány dolgot:

  • Figyeljen egy egyéni kezelőportra. Az alkalmazásnak egy adott portot kell figyelnie. A változó FUNCTIONS_CUSTOMHANDLER_PORT a szükséges értéket tartalmazza. A port értékét a következő kóddal keresheti meg:

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

  • Konfigurálja az alapértelmezett végrehajtható elérési utat. Mivel végrehajtható fájlt készít, meg kell adnia a Functions-alkalmazásprojektnek, hogy hol található.

    Keresse meg a function.json fájlt a projekt gyökérkönyvtárában. A customHandler szakaszban adja meg a defaultExecutablePath elemet. Íme egy példa arra, hogy hogyan nézhet ki:

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

  • Kérelemtovábbítás engedélyezése. Ha EGY HTTP-eseményindítót használó függvényt használ, az alkalmazást kissé másképp szeretné konfigurálni, mint ha más típusú eseményindítóval (például üzenetsor-eseményindítóval) foglalkozna.

    A nevű enableForwardingHttpRequesttulajdonság engedélyezése Ha ez a tulajdonság engedélyezve van, a következő módokon módosítja a kérés kezelésének viselkedését:

    • Az eredeti kérelem másolata. A HTTP-kérés nem tartalmazza az egyéni kezelő kérésének hasznos adatait. Ehelyett a Functions-gazdagép meghívja a kezelőt az eredeti HTTP-kérés másolatával.

    • Ugyanaz az elérési út, mint az eredeti kérelem. A Functions-gazdagép ugyanazzal az elérési úttal hívja meg a kezelőt, mint az eredeti kérés.

      Útvonal és útvonalkezelő definiálásakor meg kell határoznia az útválasztás beállításának módját. Tegyük fel, hogy az alábbi projektszerkezetet tartalmazza:

      hello/
  function.json

      A vázlatban lévő fájlok alapértelmezés szerint útvonalra /api/hello vannak leképezve. Az útvonal beállításához használt kódban meg kell adnia a teljes útvonalat:

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

      Ha nem engedélyezte volna ezt a beállítást, más típusú eseményindítók és kötések esetében elegendő lett volna megadni az útválasztó kódját "/hello" formában.

    • A kezelő válaszának másolata. A Functions-gazdagép az eredeti kérésre adott válaszként visszaadja a kezelő HTTP-válaszának egy példányát.

Az előző példában a végrehajtható fájl a következő mygoapp.exe: . A példa feltételezi, hogy a végrehajtható fájlt egy úgynevezett mygoapp.gofájlból hozza létre, de a Go-fájlt bárminek elnevezheti. Linux vagy macOS rendszeren a végrehajtható fájl nem rendelkezik bővítménysel.

Az alkalmazás létrehozása

A webalkalmazás létrehozása ezen a ponton nem sokban különbözik attól, hogy webalkalmazást készít a Go használatával. Mindaddig, amíg elvégezte az előző szakaszban leírt konfigurációt, mind be van állítva.

Most meg kell tennie a következő lépéseket:

  1. Olvassa el a portot.
  2. HTTP-kiszolgálópéldány példányosítása.
  3. Útvonalak és útvonalkezelők definiálása.
  4. Kezdjen el figyelni a porton.
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)