Azure-függvények fejlesztése a Visual Studióval

  • Cikk
  • 21 perc alatt elolvasható

A Visual Studio lehetővé teszi C#-osztálykódtár-függvények fejlesztését, tesztelését és üzembe helyezését az Azure-ban. Ha ez az első Azure Functions, olvassa el a Bevezetés a Azure Functions című témakört.

A Visual Studio a következő előnyöket nyújtja a függvények fejlesztésekor:

  • Függvények szerkesztése, létrehozása és futtatása a helyi fejlesztőszámítógépen.
  • Tegye közzé a Azure Functions projektet közvetlenül az Azure-ban, és szükség szerint hozzon létre Azure-erőforrásokat.
  • C#-attribútumok használatával deklarálhatja a függvénykötéseket közvetlenül a C#-kódban.
  • Előre lefordított C#-függvények fejlesztése és üzembe helyezése. Az előre megfelelt függvények jobb hidegindítási teljesítményt biztosítanak, mint a C# szkriptalapú függvények.
  • A függvények kódolása C# nyelven, a Visual Studio fejlesztésének minden előnyével.

Ez a cikk részletesen ismerteti, hogyan fejleszthet C#-osztálytárfüggvényeket a Visual Studióval, és hogyan teheti közzé őket az Azure-ban. Mielőtt elolvassa ezt a cikket, fontolja meg a Visual Studio Functions rövid útmutatójának elvégzését.

Ha másként nem jelezzük, a megjelenített eljárások és példák a Visual Studio 2022-hez tartoznak. A Visual Studio 2022-kiadásokról további információt a kibocsátási megjegyzésekben vagy az előzetes verzió kibocsátási megjegyzéseiben talál.

Előfeltételek

  • Azure Functions eszközök. Az Azure Function Tools hozzáadásához vegye fel az Azure-fejlesztési számítási feladatot a Visual Studio-telepítésbe. Ha Visual Studio 2017-et használ, előfordulhat, hogy további telepítési lépéseket kell tennie.

  • A közzétételi folyamat során más szükséges erőforrások, például egy Azure Storage-fiók is létrejönnek az előfizetésben.

  • Ha nem rendelkezik Azure-előfizetéssel, a kezdés előtt hozzon létre egy ingyenes Azure-fiókot .

Azure Functions-projekt létrehozása

A Visual Studio Azure Functions projektsablonja létrehoz egy C#-osztálytárprojektet, amelyet közzétehet egy függvényalkalmazásban az Azure-ban. A függvényalkalmazásokkal logikai egységként csoportosíthatja a függvényeket az erőforrások egyszerűbb kezelése, üzembe helyezése, skálázása és megosztása érdekében.

  1. A Visual Studio menüjében válassza azÚj>projekt fájlja> lehetőséget.

  2. Az Új projekt létrehozása területen írja be a függvényeket a keresőmezőbe, válassza ki a Azure Functions sablont, majd válassza a Tovább gombot.

  3. Az Új projekt konfigurálása területen adja meg a projekt projektnevét , majd válassza a Létrehozás lehetőséget. A függvényalkalmazás nevének egy C#-névtérként is érvényesnek kell lennie, ezért ne használjon aláhúzásjeleket, kötőjeleket vagy más nem alfanumerikus karaktereket.

  4. Az Új Azure Functions alkalmazásbeállítások létrehozásához használja az alábbi táblázatban szereplő értékeket:

    Beállítás Érték Leírás
    .NET-verzió .NET 6 Ez az érték létrehoz egy függvényprojektet, amely folyamatban fut a Azure Functions futtatókörnyezet 4.x-es verziójával. Az Azure Functions 1.x támogatja a .NET-keretrendszert. További információ: Azure Functions futtatókörnyezeti verziók áttekintése.
    Függvénysablon HTTP-eseményindító Ez az érték létrehoz egy HTTP-kérés által aktivált függvényt.
    Tárfiók (AzureWebJobsStorage) Tárolóemulátor Mivel az Azure-ban egy függvényalkalmazáshoz tárfiók szükséges, a rendszer hozzárendel vagy létrehoz egyet, amikor közzéteszi a projektet az Azure-ban. A HTTP-eseményindítók nem használnak Azure Storage-fiókot kapcsolati sztring; minden más eseményindító-típushoz érvényes Azure Storage-fiók kapcsolati sztring szükséges.
    Engedélyszint Névtelen A létrehozott függvényt bármely ügyfél elindíthatja, kulcs megadása nélkül. Ez az engedélyezési beállítás megkönnyíti az új függvény tesztelését. További információ a kulcsokról és az engedélyezésről: Engedélyezési kulcsok , HTTP- és webhookkötések.

    projektbeállítások Azure Functions

    Győződjön meg arról, hogy az Engedélyezési szintetNévtelen értékre állítja. Ha a függvény alapértelmezett szintjét választja, a függvénykulcsot be kell mutatnia a függvényvégpont eléréséhez szükséges kérésekben.

  5. Válassza a Létrehozás lehetőséget a függvényprojekt és a HTTP-eseményindító függvény létrehozásához.

Miután létrehozott egy Azure Functions projektet, a projektsablon létrehoz egy C#-projektet, telepíti a Microsoft.NET.Sdk.Functions NuGet-csomagot, és beállítja a cél keretrendszert. Az új projekt a következő fájlokat tartalmazza:

  • host.json: Lehetővé teszi a Functions-gazdagép konfigurálását. Ezek a beállítások helyi és Azure-beli futtatáskor is érvényesek. További információ: host.json referencia.

  • local.settings.json: Fenntartja a függvények helyi futtatásakor használt beállításokat. Ezek a beállítások nem használhatók az Azure-ban való futtatáskor. További információ: Helyi beállítások fájlja.

    Fontos

    Mivel a local.settings.json fájl tartalmazhat titkos kódokat, ki kell zárnia a projektforrás-vezérlőből. Győződjön meg arról, hogy a Fájl másolása kimeneti könyvtárba beállításnál a Másolás, ha újabb beállítás van beállítva.

További információ: Functions osztálykódtár projekt.

Helyi beállítások

Ha függvényalkalmazásban fut az Azure-ban, a függvények által megkövetelt beállítások biztonságosan tárolódnak az alkalmazásbeállításokban. A helyi fejlesztés során ezeket a beállításokat a rendszer ehelyett hozzáadja az Values objektumhoz a local.settings.json fájlban. A local.settings.json fájl a helyi fejlesztési eszközök által használt beállításokat is tárolja.

Mivel a local.settings.json titkos kódokat, például kapcsolati sztringeket tartalmazhat, soha ne tárolja távoli adattárban. A helyi beállításokról további információt a Helyi beállítások fájlban talál.

A Visual Studio nem tölti fel automatikusan a beállításokat a local.settings.json fájlba a projekt közzétételekor. Ha meg szeretné győződni arról, hogy ezek a beállítások az Azure-beli függvényalkalmazásban is léteznek, töltse fel őket a projekt közzététele után. További információ: Függvényalkalmazás beállításai. A gyűjtemény értékei ConnectionStrings soha nem lesznek közzétéve.

A kód környezeti változóként is felolvassa a függvényalkalmazás beállításainak értékeit. További információ: Környezeti változók.

A projekt konfigurálása helyi fejlesztéshez

A Functions-futtatókörnyezet belsőleg egy Azure Storage-fiókot használ. A HTTP-t és a webhookokat kivéve minden eseményindító-típusnál állítsa a Values.AzureWebJobsStorage kulcsot érvényes Azure Storage-fiókra kapcsolati sztring. A függvényalkalmazás az Azurite emulátort is használhatja a AzureWebJobsStorage projekt által igényelt kapcsolati beállításhoz. Az emulátor használatához állítsa a értékét a értékre AzureWebJobsStorageUseDevelopmentStorage=true. Módosítsa ezt a beállítást egy tényleges tárfiókra kapcsolati sztring az üzembe helyezés előtt. További információ: Helyi tárolóemulátor.

A tárfiók kapcsolati sztring beállítása:

  1. Az Azure Portalon lépjen a tárfiókra.

  2. A Hozzáférési kulcsok lap Biztonság + hálózatkezelés területén másolja ki a key1kapcsolati sztringet.

  3. A projektben nyissa meg a local.settings.json fájlt, és állítsa a AzureWebJobsStorage kulcs értékét a másolt kapcsolati sztring.

  4. Ismételje meg az előző lépést, ha egyedi kulcsokat szeretne hozzáadni a Values tömbhöz a függvények által igényelt egyéb kapcsolatokhoz.

Függvény hozzáadása a projekthez

A C#-osztály kódtárfüggvényeiben a függvény által használt kötések a kód attribútumainak alkalmazásával vannak definiálva. Amikor a megadott sablonokból hozza létre a függvény eseményindítóit, a rendszer alkalmazza a triggerattribútumokat.

  1. A Megoldáskezelő kattintson a jobb gombbal a projektcsomópontra, és válassza azÚj elemhozzáadása> lehetőséget.

  2. Válassza az Azure-függvény lehetőséget, adja meg az osztály nevét , majd válassza a Hozzáadás lehetőséget.

  3. Válassza ki az eseményindítót, állítsa be a kötés tulajdonságait, majd válassza a Hozzáadás lehetőséget. Az alábbi példa a Queue Storage-eseményindító függvény létrehozásának beállításait mutatja be.

    Queue Storage-eseményindító függvény létrehozása

    Ezután a rendszer kérni fogja, hogy válasszon az Azurite Storage Emulator vagy egy kiépített Azure Storage-fiókra való hivatkozás közül.

    Ez az eseményindító-példa egy nevű kulccsal QueueStoragerendelkező kapcsolati sztring használ. Ez a local.settings.json fájlban tárolt kulcs vagy az Azurite emulátorra vagy egy Azure Storage-fiókra hivatkozik.

  4. Vizsgálja meg az újonnan hozzáadott osztályt. Megjelenik egy statikus Run() metódus, amely az FunctionName attribútummal van társítva. Ez az attribútum azt jelzi, hogy a metódus a függvény belépési pontja.

    A következő C#-osztály például egy alapszintű Queue Storage-eseményindító függvényt jelöl:

    using System;
using Microsoft.Azure.WebJobs;
using Microsoft.Azure.WebJobs.Host;
using Microsoft.Extensions.Logging;

namespace FunctionApp1
{
    public static class Function1
    {
        [FunctionName("QueueTriggerCSharp")]
        public static void Run([QueueTrigger("myqueue-items", 
            Connection = "QueueStorage")]string myQueueItem, ILogger log)
        {
            log.LogInformation($"C# Queue trigger function processed: {myQueueItem}");
        }
    }
}

A rendszer egy kötésspecifikus attribútumot alkalmaz a belépésipont-metódushoz megadott összes kötési paraméterre. Az attribútum a kötési adatokat paraméterekként veszi fel. Az előző példában az első paraméter egy QueueTrigger attribútummal rendelkezik, amely egy Queue Storage-eseményindító függvényt jelez. Az üzenetsor neve és kapcsolati sztring beállítás neve paraméterként lesz átadva az QueueTrigger attribútumnak. További információ: Azure Queue Storage-kötések Azure Functions.

A fenti eljárással további függvényeket adhat hozzá a függvényalkalmazás projektjéhez. A projekt minden függvénye eltérő eseményindítóval rendelkezhet, de egy függvénynek pontosan egy eseményindítóval kell rendelkeznie. További információ: Azure Functions triggerek és kötések fogalmai.

Kötések hozzáadása

Az eseményindítókhoz hasonlóan a bemeneti és kimeneti kötések is kötési attribútumokként lesznek hozzáadva a függvényhez. Adjon kötéseket egy függvényhez az alábbiak szerint:

  1. Győződjön meg arról, hogy a projektet helyi fejlesztésre konfigurálta.

  2. Adja hozzá a megfelelő NuGet-bővítménycsomagot az adott kötéshez. Ehhez keresse meg a kötésre vonatkozó, kötésspecifikus NuGet-csomagra vonatkozó követelményeket a kötés referenciacikkében. Az Event Hubs-eseményindító csomagkövetelményeit például az Event Hubs kötési referenciacikkében találja.

  3. Egy adott csomag telepítéséhez használja az alábbi parancsot a Csomagkezelő konzolon:

    Install-Package Microsoft.Azure.WebJobs.Extensions.<BINDING_TYPE> -Version <TARGET_VERSION>

    Ebben a példában cserélje le <BINDING_TYPE> a elemet a kötési bővítményre jellemző névre és <TARGET_VERSION> a csomag egy adott verziójára, például 3.0.0-beta5: . Az érvényes verziók a NuGet.org egyes csomagoldalain jelennek meg. A Functions 1.x vagy 2.x futtatókörnyezetének megfelelő főverziókat a kötés referenciacikke határozza meg.

  4. Ha vannak olyan alkalmazásbeállítások, amelyekre a kötésnek szüksége van, adja hozzá őket a Valuesgyűjteményhez a helyi beállításfájlban.

    A függvény ezeket az értékeket használja, amikor helyileg fut. Amikor a függvény az Azure-beli függvényalkalmazásban fut, a függvényalkalmazás beállításait használja.

  5. Adja hozzá a megfelelő kötési attribútumot a metódus aláírásához. Az alábbi példában egy üzenetsor-üzenet aktiválja a függvényt, és a kimeneti kötés létrehoz egy új üzenetsor-üzenetet ugyanazzal a szöveggel egy másik üzenetsorban.

    public static class SimpleExampleWithOutput
{
    [FunctionName("CopyQueueMessage")]
    public static void Run(
        [QueueTrigger("myqueue-items-source", Connection = "AzureWebJobsStorage")] string myQueueItem, 
        [Queue("myqueue-items-destination", Connection = "AzureWebJobsStorage")] out string myQueueItemCopy,
        ILogger log)
    {
        log.LogInformation($"CopyQueueMessage function processed: {myQueueItem}");
        myQueueItemCopy = myQueueItem;
    }
}

    A Queue Storage-hoz való csatlakozás a beállításból származik AzureWebJobsStorage . További információt az adott kötés referenciacikkében talál.

A Functions által támogatott kötések teljes listáját lásd: Támogatott kötések.

Függvények helyi futtatása

Az Azure Functions Core Tools lehetővé teszi Azure Functions-projektek helyi fejlesztői számítógépen való futtatását. Amikor lenyomja az F5 billentyűt egy Functions-projekt hibakereséséhez, a helyi Functions-gazdagép (func.exe) elkezd figyelni egy helyi porton (általában 7071). A rendszer minden hívható függvényvégpontot a kimenetbe ír, és ezeket a végpontokat használhatja a függvények teszteléséhez. További információ: A Azure Functions Core Tools használata. A rendszer arra kéri, hogy telepítse ezeket az eszközöket, amikor először indít el függvényt a Visual Studióból.

A függvény elindítása a Visual Studióban hibakeresési módban:

  1. Nyomja le az F5 billentyűt. Ha a rendszer kéri, fogadja el a Visual Studio kérését az Azure Functions Core (CLI) eszközök telepítéséhez. Előfordulhat, hogy engedélyeznie kell egy tűzfalkivételt, hogy az eszközök kezelni tudják a HTTP-kéréseket.

  2. Futtassa a projektet, és tesztelje a kódot úgy, ahogyan egy üzembe helyezett függvényt.

    Ha hibakeresési módban futtatja a Visual Studiót, a töréspontok a várt módon lesznek találatok.

A Visual Studio használatával végzett részletesebb tesztelési forgatókönyvért lásd: Függvények tesztelése.

Közzététel az Azure-ban

Amikor a Visual Studióból teszi közzé, az a két üzembe helyezési módszer egyikét használja:

Az alábbi lépésekkel közzéteheti a projektet egy függvényalkalmazásban az Azure-ban.

  1. A Megoldáskezelőben kattintson a jobb gombbal a projektre, és válassza a Publish (Közzététel) lehetőséget. A Cél területen válassza az Azure , majd a Tovább lehetőséget.

    Képernyőkép a közzétételi ablakról.

  2. Válassza az Azure-függvényalkalmazás (Windows) lehetőséget az Adott célhoz, amely létrehoz egy Windowson futó függvényalkalmazást, majd válassza a Tovább gombot.

    Képernyőkép a közzétételi ablakról adott céllal.

  3. A függvénypéldányban válassza az Új Azure-függvény létrehozása... lehetőséget.

    Képernyőkép egy új függvényalkalmazás-példány létrehozásáról.

  4. Hozzon létre egy új példányt a következő táblázatban megadott értékekkel:

    Beállítás Érték Leírás
    Név Globálisan egyedi név Az új függvényalkalmazást azonosító egyedi név. Fogadja el ezt a nevet, vagy írjon be egy új nevet. Az érvényes karakterek a következők: a-z, 0-9és -.
    Előfizetés Az Ön előfizetése A használandó előfizetés. Fogadja el ezt az előfizetést, vagy válasszon egy újat a legördülő listából.
    Erőforráscsoport Az erőforráscsoport neve Az erőforráscsoport, amelyben létre szeretné hozni a függvényalkalmazást. Válasszon ki egy meglévő erőforráscsoportot a legördülő listából, vagy válassza az Új lehetőséget egy új erőforráscsoport létrehozásához.
    Csomag típusa Használat Amikor egy használatalapú csomagban futó függvényalkalmazásban teszi közzé a projektet, csak a függvényalkalmazás végrehajtásáért kell fizetnie. Más üzemeltetési csomagok magasabb költségekkel járnak.
    Hely Az App Service helye Válasszon egy Helyet egy Önhöz közeli régióban vagy a függvények által elért egyéb szolgáltatások közül.
    Azure Storage Általános célú tárfiók A Functions futtatókörnyezetének szüksége van egy Azure Storage-fiókra. Általános célú tárfiók konfigurálásához válassza az Új lehetőséget. Választhat olyan meglévő fiókot is, amely megfelel a tárfiók követelményeinek.

    Képernyőkép a App Service létrehozása párbeszédpanelről.

  5. A Létrehozás lehetőséget választva hozzon létre egy függvényalkalmazást és annak kapcsolódó erőforrásait az Azure-ban. Az erőforrás-létrehozás állapota az ablak bal alsó sarkában látható.

  6. A Functions-példányban ellenőrizze, hogy a Futtatás csomagfájlból jelölőnégyzet be van-e jelölve. A függvényalkalmazás a Zip Deploy használatával van üzembe helyezve, és engedélyezve van a Csomagból futtatás mód. A Zip Deploy az ajánlott üzembe helyezési módszer a függvényprojekthez, amely jobb teljesítményt eredményez.

    Képernyőkép a profil létrehozásának befejezéséről.

  7. Válassza a Befejezés lehetőséget, majd a Közzététel lapon válassza a Közzététel lehetőséget a projektfájlokat tartalmazó csomag üzembe helyezéséhez az Új függvényalkalmazásban az Azure-ban.

    Az üzembe helyezés befejezése után az Azure-beli függvényalkalmazás gyökér URL-címe megjelenik a Közzététel lapon.

  8. A Közzététel lap Üzemeltetés szakaszában válassza a Megnyitás Azure Portal lehetőséget. Ezzel megnyitja az új függvényalkalmazás Azure-erőforrását a Azure Portal.

    Képernyőkép a Sikeres közzététel üzenetről.

A függvényalkalmazás beállításai

A Visual Studio nem tölti fel automatikusan ezeket a beállításokat a projekt közzétételekor. A local.settings.json fájlban hozzáadott beállításokat az Azure-beli függvényalkalmazáshoz is hozzá kell adnia.

A szükséges beállításokat a legegyszerűbben úgy töltheti fel az Azure-beli függvényalkalmazásba, ha kibontja a Üzemeltetés szakasz melletti három elemet, majd a projekt sikeres közzététele után megjelenő Manage Azure App Service settings (Beállítások kezelése) hivatkozást választja.

Beállítások a Közzététel ablakban

Ha ezt a hivatkozást választja, megjelenik a függvényalkalmazás Alkalmazásbeállítások párbeszédpanelje, ahol új alkalmazásbeállításokat adhat hozzá, vagy módosíthatja a meglévőket.

Alkalmazásbeállítások

A Local egy beállításértéket jelenít meg a local.settings.json fájlban, a Távoli pedig egy aktuális beállításértéket jelenít meg az Azure-beli függvényalkalmazásban. Új alkalmazásbeállítás létrehozásához válassza a Beállítás hozzáadása lehetőséget. A Helyi hivatkozás értékének beszúrása hivatkozással másolhat egy beállításértéket a Távoli mezőre. A függőben lévő módosítások a helyi beállításfájlba és a függvényalkalmazásba lesznek írva, amikor az OK gombot választja.

Megjegyzés

Alapértelmezés szerint a local.settings.json fájl nincs beadva a verziókövetésbe. Ez azt jelenti, hogy ha a forrásvezérlőből klónozza a helyi Functions-projektet, a projekt nem rendelkezik local.settings.json fájllal. Ebben az esetben manuálisan kell létrehoznia a local.settings.json fájlt a projekt gyökerében, hogy az Alkalmazásbeállítások párbeszédpanel a várt módon működjön.

Az alkalmazásbeállításokat az alábbi módokon is kezelheti:

Távoli hibakeresés

A függvényalkalmazás távoli hibakereséséhez közzé kell tennie a projekt hibakeresési konfigurációját. Engedélyeznie kell a távoli hibakeresést is az Azure-beli függvényalkalmazásban.

Ez a szakasz feltételezi, hogy már közzétette a függvényalkalmazást egy kiadási konfigurációval.

Távoli hibakeresési szempontok

  • Éles szolgáltatásban nem ajánlott a távoli hibakeresés.
  • Ha engedélyezve van a Just My Code hibakeresése , tiltsa le.
  • Távoli hibakeresés esetén kerülje a töréspontoknál a hosszú leállást. Az Azure néhány percnél hosszabb ideig leállított folyamatot nem válaszoló folyamatként kezeli, és leállítja.
  • Hibakeresés közben a kiszolgáló adatokat küld a Visual Studiónak, ami hatással lehet a sávszélesség díjaira. A sávszélesség-díjszabással kapcsolatos információkért lásd az Azure díjszabását ismertető cikket.
  • A távoli hibakeresés 48 óra elteltével automatikusan le lesz tiltva a függvényalkalmazásban. 48 óra elteltével újra el kell végeznie a távoli hibakeresést.

A hibakereső csatolása

A hibakereső csatlakoztatásának módja a végrehajtási módtól függ. Izolált feldolgozófolyamat-alkalmazás hibakeresésekor jelenleg egy külön .NET-folyamathoz kell csatolnia a távoli hibakeresőt, és számos egyéb konfigurációs lépésre van szükség.

Ha végzett, tiltsa le a távoli hibakeresést.

Távoli hibakereső csatlakoztatása folyamatban lévő függvényalkalmazáshoz a Functions-gazdagéppel:

  • A Közzététel lapon válassza a három pontot (...) az Üzemeltetés szakaszban, majd válassza a Hibakereső csatolása lehetőséget.

    Képernyőkép a hibakereső Visual Studióból való csatolásáról.

A Visual Studio csatlakozik a függvényalkalmazáshoz, és engedélyezi a távoli hibakeresést, ha még nincs engedélyezve. Emellett megkeresi és csatolja a hibakeresőt az alkalmazás gazdagépfolyamatához. Ezen a ponton a szokásos módon végezhet hibakeresést a függvényalkalmazásban.

Távoli hibakeresés letiltása

Miután végzett a kód távoli hibakeresésével, tiltsa le a távoli hibakeresést a Azure Portal. Ha elfelejti, a távoli hibakeresés 48 óra elteltével automatikusan le lesz tiltva.

  1. A projekt Közzététel lapján válassza a három pontot (...) az Üzemeltetés szakaszban, majd válassza a Megnyitás Azure Portal. Ez a művelet abban a Azure Portal nyitja meg a függvényalkalmazást, amelyre a projekt telepítve van.

  2. A függvényalkalmazásban válassza a Beállításokterületen a Konfiguráció lehetőséget, válassza az Általános beállítások elemet, állítsa a Távoli hibakeresésbeállítást Ki értékre, majd válassza a Mentés , majd a Folytatás lehetőséget.

A függvényalkalmazás újraindítása után már nem tud távolról csatlakozni a távoli folyamatokhoz. A Azure Portal ezen lapjának használatával engedélyezheti a távoli hibakeresést a Visual Studión kívül.

Monitorozási függvények

A függvények végrehajtásának figyelésének ajánlott módja a függvényalkalmazás integrálása a Azure-alkalmazás Insights szolgáltatással. Amikor függvényalkalmazást hoz létre a Azure Portal, ez az integráció alapértelmezés szerint megtörténik. Amikor azonban a Visual Studio közzététele során hozza létre a függvényalkalmazást, a függvényalkalmazás integrálása nem történik meg az Azure-ban. Az Application Insights függvényalkalmazáshoz való csatlakoztatásáról az Application Insights-integráció engedélyezése című témakörben olvashat.

További információ az Application Insights használatával történő monitorozásról: Monitorozási Azure Functions.

Függvények tesztelése

Ez a szakasz azt ismerteti, hogyan hozhat létre C#-függvényalkalmazás-projektet a Visual Studióban, és hogyan futtathat és tesztelhet az xUnittal.

A Azure Functions tesztelése C# nyelven a Visual Studióban

Telepítés

A környezet beállításához hozzon létre egy függvényt, és tesztelje az alkalmazást. Az alábbi lépések segítenek létrehozni a tesztek támogatásához szükséges alkalmazásokat és függvényeket:

  1. Hozzon létre egy új Functions-alkalmazást, és adja neki a Functions nevet
  2. Hozzon létre egy HTTP-függvényt a sablonból , és adja neki a MyHttpTrigger nevet.
  3. Hozzon létre egy időzítőfüggvényt a sablonból , és adja neki a MyTimerTrigger nevet.
  4. Hozzon létre egy xUnit-tesztalkalmazást a megoldásban, és adja neki a Functions.Tests nevet. Távolítsa el az alapértelmezett tesztfájlokat.
  5. Referencia hozzáadása a tesztalkalmazásból a Microsoft.AspNetCore.Mvc fájlhoz a NuGet használatával
  6. Hivatkozzon a Functions alkalmazásra aFunctions.Tests alkalmazásból.

Tesztosztályok létrehozása

A projektek létrehozása után létrehozhatja az automatikus tesztek futtatásához használt osztályokat.

Minden függvény az ILogger egy példányát használja az üzenetnaplózás kezeléséhez. Egyes tesztek nem naplóznak üzeneteket, vagy nem aggódnak a naplózás implementálásával kapcsolatban. A többi tesztnek ki kell értékelnie a naplózott üzeneteket annak megállapításához, hogy egy teszt sikeres-e.

Létre fog hozni egy nevű új osztályt ListLogger, amely a tesztelés során kiértékelendő üzenetek belső listáját tartalmazza. A szükséges ILogger felület implementálásához az osztálynak hatókörre van szüksége. Az alábbi osztály a tesztesetek hatókörét szimulálja az ListLogger osztálynak való továbbításhoz.

Hozzon létre egy új osztályt a Functions.Testsprojektben NullScope.cs néven, és írja be a következő kódot:

using System;

namespace Functions.Tests
{
    public class NullScope : IDisposable
    {
        public static NullScope Instance { get; } = new NullScope();

        private NullScope() { }

        public void Dispose() { }
    }
}

Ezután hozzon létre egy új osztályt a Functions.Tests projektben ListLogger.cs néven, és írja be a következő kódot:

using Microsoft.Extensions.Logging;
using System;
using System.Collections.Generic;
using System.Text;

namespace Functions.Tests
{
    public class ListLogger : ILogger
    {
        public IList<string> Logs;

        public IDisposable BeginScope<TState>(TState state) => NullScope.Instance;

        public bool IsEnabled(LogLevel logLevel) => false;

        public ListLogger()
        {
            this.Logs = new List<string>();
        }

        public void Log<TState>(LogLevel logLevel,
                                EventId eventId,
                                TState state,
                                Exception exception,
                                Func<TState, Exception, string> formatter)
        {
            string message = formatter(state, exception);
            this.Logs.Add(message);
        }
    }
}

Az ListLogger osztály a következő tagokat valósítja meg az ILogger interfész által szerződött módon:

  • BeginScope: A hatókörök kontextust adnak a naplózáshoz. Ebben az esetben a teszt csak a osztály statikus példányára mutat, NullScope hogy a teszt működjön.

  • IsEnabled: Az alapértelmezett érték false van megadva.

  • Napló: Ez a metódus a megadott formatter függvénnyel formázza az üzenetet, majd hozzáadja az eredményként kapott szöveget a Logs gyűjteményhez.

A Logs gyűjtemény a példánya List<string> , és inicializálva van a konstruktorban.

Ezután hozzon létre egy új fájlt a Functions.Tests projektben LoggerTypes.cs néven, és írja be a következő kódot:

namespace Functions.Tests
{
    public enum LoggerTypes
    {
        Null,
        List
    }
}

Ez az enumerálás határozza meg a tesztek által használt naplózó típusát.

Most hozzon létre egy új osztályt a Functions.Testsprojektben TestFactory.cs néven, és írja be a következő kódot:

using Microsoft.AspNetCore.Http;
using Microsoft.AspNetCore.Http.Internal;
using Microsoft.Extensions.Logging;
using Microsoft.Extensions.Logging.Abstractions;
using Microsoft.Extensions.Primitives;
using System.Collections.Generic;

namespace Functions.Tests
{
    public class TestFactory
    {
        public static IEnumerable<object[]> Data()
        {
            return new List<object[]>
            {
                new object[] { "name", "Bill" },
                new object[] { "name", "Paul" },
                new object[] { "name", "Steve" }

            };
        }

        private static Dictionary<string, StringValues> CreateDictionary(string key, string value)
        {
            var qs = new Dictionary<string, StringValues>
            {
                { key, value }
            };
            return qs;
        }

        public static HttpRequest CreateHttpRequest(string queryStringKey, string queryStringValue)
        {
            var context = new DefaultHttpContext();
            var request = context.Request;
            request.Query = new QueryCollection(CreateDictionary(queryStringKey, queryStringValue));
            return request;
        }

        public static ILogger CreateLogger(LoggerTypes type = LoggerTypes.Null)
        {
            ILogger logger;

            if (type == LoggerTypes.List)
            {
                logger = new ListLogger();
            }
            else
            {
                logger = NullLoggerFactory.Instance.CreateLogger("Null Logger");
            }

            return logger;
        }
    }
}

Az TestFactory osztály a következő tagokat valósítja meg:

  • Adatok: Ez a tulajdonság a mintaadatok IEnumerable gyűjteményét adja vissza. A kulcsértékpárok olyan értékeket jelölnek, amelyek egy lekérdezési sztringbe kerülnek.

  • CreateDictionary: Ez a metódus egy kulcs/érték párt fogad el argumentumként, és egy újat Dictionary ad vissza, amelyet a lekérdezési QueryCollection sztring értékeinek ábrázolására használnak.

  • CreateHttpRequest: Ez a metódus létrehoz egy HTTP-kérést a megadott lekérdezési sztring paramétereivel inicializálva.

  • CreateLogger: A naplózó típusa alapján ez a metódus egy teszteléshez használt naplózóosztályt ad vissza. A ListLogger naplózott üzenetek nyomon követése a tesztekben való kiértékeléshez.

Végül hozzon létre egy új osztályt a Functions.Tests projektben FunctionsTests.cs néven, és írja be a következő kódot:

using Microsoft.AspNetCore.Mvc;
using Microsoft.Extensions.Logging;
using Xunit;

namespace Functions.Tests
{
    public class FunctionsTests
    {
        private readonly ILogger logger = TestFactory.CreateLogger();

        [Fact]
        public async void Http_trigger_should_return_known_string()
        {
            var request = TestFactory.CreateHttpRequest("name", "Bill");
            var response = (OkObjectResult)await MyHttpTrigger.Run(request, logger);
            Assert.Equal("Hello, Bill. This HTTP triggered function executed successfully.", response.Value);
        }

        [Theory]
        [MemberData(nameof(TestFactory.Data), MemberType = typeof(TestFactory))]
        public async void Http_trigger_should_return_known_string_from_member_data(string queryStringKey, string queryStringValue)
        {
            var request = TestFactory.CreateHttpRequest(queryStringKey, queryStringValue);
            var response = (OkObjectResult)await MyHttpTrigger.Run(request, logger);
            Assert.Equal($"Hello, {queryStringValue}. This HTTP triggered function executed successfully.", response.Value);
        }

        [Fact]
        public void Timer_should_log_message()
        {
            var logger = (ListLogger)TestFactory.CreateLogger(LoggerTypes.List);
            new MyTimerTrigger().Run(null, logger);
            var msg = logger.Logs[0];
            Assert.Contains("C# Timer trigger function executed at", msg);
        }
    }
}

Az ebben az osztályban implementált tagok a következők:

  • Http_trigger_should_return_known_string: Ez a teszt létrehoz egy kérést egy HTTP-függvényhez tartozó lekérdezési name=Bill sztringértékekkel, és ellenőrzi, hogy a rendszer a várt választ adja-e vissza.

  • Http_trigger_should_return_string_from_member_data: Ez a teszt xUnit attribútumokat használ a HTTP-függvény mintaadatainak megadásához.

  • Timer_should_log_message: Ez a teszt létrehoz egy példányt ListLogger , és átadja azt egy időzítőfüggvénynek. A függvény futtatása után a rendszer ellenőrzi, hogy a várt üzenet szerepel-e a naplóban.

Ha hozzá szeretne férni a tesztek alkalmazásbeállításaihoz, a szimulált környezeti változóértékeket tartalmazó példányt IConfigurationbeszúrhatja a függvénybe.

Tesztek futtatása

A tesztek futtatásához nyissa meg a Tesztböngészőt , és válassza a Minden teszt futtatása nézetben lehetőséget.

A Azure Functions tesztelése C# nyelven a Visual Studióban

Hibakeresési tesztek

A tesztek hibakereséséhez állítson be egy töréspontot egy teszten, lépjen a Tesztböngészőre , és válassza a Hibakeresés futtatása > utolsó futtatás lehetőséget.

Azure Functions eszközök a Visual Studio 2017-ben

Azure Functions Eszközök a Visual Studio 2017-től kezdődően elérhetők az Azure fejlesztési számítási feladataiban. A Visual Studio 2017-ben az Azure fejlesztési számítási feladatai külön bővítményként telepítik az Azure Functions Tools eszközt. A Visual Studio 2019-ben és újabb verzióiban az Azure Functions eszközök bővítmény a Visual Studio részeként frissül.

A Visual Studio 2017 telepítésekor győződjön meg arról, hogy az Azure Functions Tools legújabb verzióját használja. Az alábbi szakaszok bemutatják, hogyan ellenőrizheti és (ha szükséges) frissítheti a Azure Functions Tools bővítményt a Visual Studio 2017-ben.

Az eszközök verziójának ellenőrzése a Visual Studio 2017-ben

  1. Az Eszközök menüben válassza a Bővítmények és Frissítések lehetőséget. Bontsa ki a Telepített>eszközök elemet, majd válassza a Azure Functions és a Webes feladatok eszközei elemet.

    A Functions-eszközök verziójának ellenőrzése

  2. Jegyezze fel a telepített verziót , és hasonlítsa össze ezt a verziót a kibocsátási megjegyzésekben felsorolt legújabb verzióval.

  3. Ha régebbi verziót használ, frissítse eszközeit a Visual Studióban az alábbi szakaszban látható módon.

Eszközök frissítése a Visual Studióban

  1. A Bővítmények és Frissítések párbeszédpanelen bontsa ki a Frissítések>Visual Studio Marketplace elemet, válassza a Azure Functions és a Webes feladatok eszközei elemet, majd válassza a Frissítés lehetőséget.

    A Functions-eszközök verziójának frissítése

  2. Az eszközök frissítésének letöltése után válassza a Bezárás lehetőséget, majd zárja be a Visual Studiót az eszközök frissítésének a VSIX Installerrel való aktiválásához.

  3. A VSIX Installerben válassza a Módosítás lehetőséget az eszközök frissítéséhez.

  4. A frissítés befejezése után válassza a Bezárás lehetőséget, majd indítsa újra a Visual Studiót.

Következő lépések

További információ a Azure Functions Core Toolsról: Azure Functions Core Tools használata.

A függvények .NET-osztálykódtárként való fejlesztéséről további információt a Azure Functions C# fejlesztői referenciában talál. Ez a cikk példákra is hivatkozik, amelyek bemutatja, hogyan deklarálhatók az attribútumok a Azure Functions által támogatott különböző típusú kötések.