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

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 a felület az első az Azure Functionsben, tekintse meg az Azure Functions bemutatása 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, összeállítása és futtatása a helyi fejlesztői számítógépen.
  • Tegye közzé az Azure Functions-projektet közvetlenül az Azure-ban, és szükség szerint hozzon létre Azure-erőforrásokat.
  • A C#-attribútumokkal függvénykötéseket deklarálhat 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.
  • Kódozza a függvényeket C#-ban, miközben a Visual Studio fejlesztése minden előnyét kihasználja.

Ez a cikk részletesen bemutatja, hogyan fejleszthet C#-osztálytárfüggvényeket a Visual Studióval, és hogyan teheti közzé őket az Azure-ban. A cikk elolvasása előtt 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 Tools. Az Azure Functions Tools hozzáadásához vegye fel az Azure fejlesztési számítási feladatait 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 követnie.

  • 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.

  • If you don't have an Azure subscription, create an Azure free account before you begin.

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. Új projekt létrehozásakor írja be a függvényeket a keresőmezőbe, válassza ki az 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 Description
    .NET-verzió .NET 6 Izolált Ez az érték létrehoz egy függvényprojektet, amely egy izolált feldolgozófolyamatban fut. További információkért tekintse meg az Azure Functions futtatókörnyezeti verzióinak áttekintését.
    Függvénysablon HTTP-eseményindító Ez az érték egy HTTP-kérés által aktivált függvényt hoz létre.
    Tárfiók (AzureWebJobsStorage) Tárolóemulátor Mivel az Azure-ban egy függvényalkalmazáshoz tárfiókra van szükség, 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.

    Azure Functions project settings

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

  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.

Az Azure Functions-projekt létrehozása után 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ót a Helyi beállítások fájlban talál.

    Fontos

    Mivel a local.settings.json fájl tartalmazhat titkos kulcsokat, ki kell zárnia a projekt forrásvezérlőjéből. Győződjön meg arról, hogy a fájl Másolás a kimeneti könyvtárba beállításnál a Másolás értékre van állítva , ha újabb.

További információ: Functions class library project.

Alkalmazásbeállítások helyi használata

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 ezek a beállítások a local.settings.json fájl gyűjteményéhez Values lesznek hozzáadva. A local.settings.json fájl a helyi fejlesztési eszközök által használt beállításokat is tárolja.

A gyűjtemény elemei a Values projekt local.settings.json fájljában a függvényalkalmazás alkalmazásbeállításainak elemeinek tükrözésére szolgálnak az Azure-ban.

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ókként is beolvassa 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ő Azure Storage-fiókot használ. A HTTP és a webhookok kivételével minden triggertí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 következő é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ó: Local Storage Emulator.

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

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

  2. Másolja az 1. kulcs Csatlakozás ion sztringjét az Access-kulcsok lap Biztonság + hálózatkezelés csoportjába.

  3. Nyissa meg a local.settings.json fájlt a projektben, é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álytárfüggvényekben 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ókat, a rendszer alkalmazza az eseményindító attribútumait.

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

  2. Válassza az Azure-függvényt, 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.

    Create a Queue storage trigger function

    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ött.

    Ez az eseményindító-példa egy kapcsolati sztring használ egy nevű kulccsalQueueStorage. 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 attribútummal elosztva. 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ési pont metódusához megadott összes kötési paraméterre. Az attribútum paraméterekként veszi fel a kötési információkat. Az előző példában az első paraméter QueueTrigger egy attribútumot alkalmaz, amely egy Queue Storage triggerfü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 az Azure Functionshez.

A fenti eljárással további függvényeket adhat hozzá a függvényalkalmazás-projekthez. 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ókat az Azure Functions triggers and bindings concepts (Az Azure Functions eseményindítói és kötési alapelvei) témakörben talál.

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 hozzá 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 a kötésre vonatkozó referenciacikkben található kötésspecifikus NuGet-csomagkövetelmények megkeresésével. 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 a következő parancsot a Csomagkezelő konzolon:

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

    Ebben a példában cserélje le <BINDING_TYPE> a kötéskiterjesztésre 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, vegye fel őket a Values gyűjteménybe a helyi beállításfájlban.

    A függvény ezeket az értékeket használja helyi futtatáskor. Amikor a függvény az Azure-ban fut a függvényalkalmazásban, 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áshoz. Az alábbi példában egy üzenetsor-üzenet aktiválja a függvényt, és a kimeneti kötés egy új üzenetsor-üzenetet hoz létre 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ó kapcsolat 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 a Támogatott kötések című témakörben találja.

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 portot (á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ó: Az 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 egy függvényt a Visual Studióból.

Ha hibakeresési módban szeretné elindítani a függvényt a Visual Studióban:

  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 is, hogy az eszközök kezelni tudják a HTTP-kéréseket.

  2. Ha a projekt fut, tesztelje a kódot úgy, ahogyan egy üzembe helyezett függvényt tesztelne.

    Ha hibakeresési módban futtatja a Visual Studiót, a rendszer a várt módon éri el a töréspontokat.

A Visual Studio használatával végzett részletesebb tesztelési forgatókönyvért lásd a Tesztelési függvények című témakört.

Közzététel az Azure platformon

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.

    Screenshot of publish window.

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

    Screenshot of publish window with specific target.

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

    Screenshot of create a new function app instance.

  4. Hozzon létre egy új példányt az alábbi táblázatban megadott értékekkel:

    Beállítás Érték Description
    Név Globálisan egyedi név Az új függvényalkalmazást azonosító egyedi név. Fogadja el ezt a nevet, vagy adjon meg 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 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 Consumption Ha a projektet egy használatalapú tervben futó függvényalkalmazásban teszi közzé, csak a függvényalkalmazás végrehajtásáért kell fizetnie. Más üzemeltetési tervek magasabb költségekkel járnak.
    Tartózkodási hely Az app service helye Válasszon egy helyet egy Önhöz közeli régióban vagy más szolgáltatásokban, amelyekhez a függvények hozzáférnek.
    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.

    Screenshot of Create App Service dialog.

  5. A Létrehozás gombra kattintva létrehozhat 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 győződjön meg arról, hogy a Csomagból futtatás fájl be van jelölve. A függvényalkalmazás üzembe helyezése a Zip Deploy használatával történik, és engedélyezve van a csomagalapú 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.

    Screenshot of Finish profile creation.

  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-ban a 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 az Azure Portalon lehetőséget. Ezzel megnyitja az új Azure-függvényalkalmazás-erőforrást az Azure Portalon.

    Screenshot of Publish success message.

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-ban is hozzá kell adnia a függvényalkalmazáshoz.

A szükséges beállítások Azure-beli függvényalkalmazásba való feltöltésének legegyszerűbb módja, ha kibontja az Üzemeltetés szakasz melletti három elemet, majd a projekt sikeres közzététele után megjelenő Azure-alkalmazás szolgáltatásbeállítások kezelése hivatkozást választja.

Settings in Publish window

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.

Application settings

A helyi érték a local.settings.json fájlban jelenik meg, 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ásával másolja a beállítás értékét a Távoli mezőbe. 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 bekapcsolva a forrásvezérlőbe. Ez azt jelenti, hogy ha a helyi Functions-projektet a forrásvezérlőből klónozza, 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ökérkönyvtárában, 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ódok egyikével 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. Emellett engedélyeznie kell a távoli hibakeresést az Azure-beli függvényalkalmazásban.

Ez a szakasz feltételezi, hogy már közzétette a függvényalkalmazásban egy kiadási konfiguráció használatá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éspontok hosszú leállását. Az Azure a néhány percnél hosszabb ideig leállított folyamatot nem válaszoló folyamatként kezeli, és leállítja.
  • A hibakeresés során a kiszolgáló adatokat küld a Visual Studióba, ami hatással lehet a sávszélesség díjaira. A sávszélesség-díjszabással kapcsolatos információkért tekintse meg az Azure díjszabását.
  • A távoli hibakeresés 48 óra elteltével automatikusan le van 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ói folyamat alkalmazásának hibakeresésekor jelenleg egy külön .NET-folyamathoz kell csatolnia a távoli hibakeresőt, és számos más konfigurációs lépésre van szükség.

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

Távoli hibakereső csatolása a Functions-gazdagéptől eltérő folyamatban futó függvényalkalmazáshoz:

  1. A Közzététel lapon válassza ki a három pontot (...) az Üzemeltetés szakaszban, majd válassza a Közzétételi profil letöltése lehetőséget. Ez a művelet letölti a közzétételi profil egy példányát, és megnyitja a letöltési helyet. Szüksége van erre a fájlra, amely tartalmazza az Azure-ban futó izolált feldolgozó folyamathoz csatolandó hitelesítő adatokat.

    Figyelmeztetés

    A .publishsettings fájl tartalmazza a függvényalkalmazás felügyeletéhez használt hitelesítő adatokat (kódolatlan). A fájl biztonsági ajánlott eljárása, hogy ideiglenesen a forráskönyvtárakon kívül tárolja (például a Könyvtárak\Dokumentumok mappában), majd törölje, miután már nincs rá szükség. A .publishsettings fájlhoz hozzáférést kapó rosszindulatú felhasználók szerkeszthetik, létrehozhatják és törölhetik a függvényalkalmazást.

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

    Screenshot of attaching the debugger from Visual Studio.

    A Visual Studio csatlakozik a függvényalkalmazáshoz, és engedélyezi a távoli hibakeresést, ha még nincs engedélyezve.

    Megjegyzés:

    Mivel a távoli hibakereső nem tud csatlakozni a gazdagép folyamatához, hibaüzenet jelenhet meg. Az alapértelmezett hibakeresés mindenesetre nem törik be a kódba.

  3. Másolja a Webhely URL-címét a Visual Studióba a Közzététel lapon.

  4. A Hibakeresés menüben válassza a Csatolás a folyamathoz lehetőséget, majd a Csatolás a folyamathoz ablakban illessze be az URL-címet a Csatlakozás ion célba, távolítsa el https:// és fűzze hozzá a portot:4024.

    Ellenőrizze, hogy a cél így néz-e <FUNCTION_APP>.azurewebsites.net:4024 ki, és nyomja le az Enter billentyűt.

    Visual Studio attach to process dialog

  5. Ha a rendszer kéri, engedélyezze a Visual Studio elérését a helyi tűzfalon keresztül.

  6. Amikor a rendszer hitelesítő adatokat kér, a helyi felhasználói hitelesítő adatok helyett válasszon egy másik fiókot (Windowson további lehetőségek ). Adja meg a userName és a userPWD értékét a közzétett profilból az e-mail-címhez és a jelszóhoz a Windows hitelesítési párbeszédpanelén. Miután biztonságos kapcsolatot létesített az üzembehelyezési kiszolgálóval, megjelennek az elérhető folyamatok.

    Visual Studio enter credential

  7. Ellenőrizze az összes felhasználó folyamatának megjelenítése lehetőséget, majd válassza a dotnet.exe lehetőséget, majd a Csatolás lehetőséget. Amikor a művelet befejeződött, a rendszer egy izolált feldolgozói folyamatban futó C#-osztálykódhoz csatlakozik. Ezen a ponton a függvényalkalmazást a szokásos módon hibakeresésre használhatja.

Távoli hibakeresés letiltása

Miután végzett a kód távoli hibakeresésével, le kell tiltania a távoli hibakeresést az Azure Portalon. A távoli hibakeresés 48 óra elteltével automatikusan le van tiltva, ha elfelejtené.

  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 az Azure Portalon lehetőséget. Ez a művelet megnyitja azt a függvényalkalmazást az Azure Portalon, amelyre a projekt telepítve van.

  2. A függvényalkalmazásban válassza a Beállítások területen a Konfiguráció lehetőséget, válassza az Általános Gépház, a Távoli hibakeresésbeállítást kikapcsolva, majd 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. Ugyanezt a lapot használhatja az Azure Portalon a Visual Studión kívüli távoli hibakeresés engedélyezéséhez.

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 Azure-alkalmazás Elemzések. Amikor függvényalkalmazást hoz létre az Azure Portalon, ez az integráció alapértelmezés szerint megtörténik. Ha 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 alkalmazás Elemzések függvényalkalmazáshoz való csatlakoztatásáról az Alkalmazás Elemzések integráció engedélyezése című témakörben olvashat.

Az Alkalmazás Elemzések használatával történő monitorozásról további információt az Azure Functions monitorozása című témakörben talál.

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 xUnittal.

Testing Azure Functions with C# in Visual Studio

Setup

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. Új Functions-alkalmazás létrehozása és a Functions elnevezése
  2. Hozzon létre egy HTTP-függvényt a sablonból, és nevezze el MyHttpTriggernek.
  3. Hozzon létre egy időzítőfüggvényt a sablonból , és nevezze el MyTimerTriggernek.
  4. Hozzon létre egy xUnit-tesztalkalmazást a megoldásban, és nevezze el Functions.Tests néven. Távolítsa el az alapértelmezett tesztfájlokat.
  5. A NuGet használatával referenciát adhat hozzá a tesztalkalmazásból a Microsoft.AspNetCore.Mvc fájlhoz
  6. Hivatkozzon a Functions alkalmazásra a Functions.Tests alkalmazásból.

Tesztosztályok létrehozása

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

Minden függvény egy ILogger-példányt vesz igénybe 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 új osztályt, ListLoggeramely tartalmazza a tesztelés során kiértékelendő üzenetek belső listáját. 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 egy hatókört szimulál a tesztesetekhez, hogy átjutjanak az ListLogger osztálynak.

Hozzon létre egy új osztályt a Functions.Tests projektben 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 az osztály statikus példányára NullScope mutat, hogy lehetővé tegye a teszt működését.

  • IsEnabled: A rendszer alapértelmezett értéket false ad meg.

  • Napló: Ez a metódus a megadott formatter függvény használatával 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 konstruktor egy példánya List<string> , és inicializálva van.

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 a tesztek által használt naplózó típusát határozza meg.

Most hozzon létre egy új osztályt a Functions.Tests projektben 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 a lekérdezési sztringbe átadott értékeket jelölik.

  • CreateDictionary: Ez a metódus argumentumként elfogad egy kulcs-/értékpárt, és visszaad egy újat Dictionary , amely a QueryCollection lekérdezési sztring értékeinek megjelenítésére szolgál.

  • CreateHttpRequest: Ez a metódus létrehoz egy HTTP-kérést a megadott lekérdezési sztringparaméterekkel 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 HTTP-függvény lekérdezési name=Bill sztringértékeivel rendelkező kérést, és ellenőrzi, hogy a várt válasz vissza lesz-e adva.

  • Http_trigger_should_return_string_from_member_data: Ez a teszt xUnit-attribútumokkal biztosít mintaadatokat a HTTP-függvénynek.

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

Ha hozzá szeretne férni az alkalmazásbeállításokhoz a tesztekben, a modellezett környezeti változóértékeket tartalmazó példányokat IConfiguration beszúrhatja a függvénybe.

Tesztek futtatása

A tesztek futtatásához lépjen a Tesztkezelőbe, és válassza az Összes teszt futtatása nézetben lehetőséget.

Testing Azure Functions with C# in Visual Studio

Hibakeresési tesztek

A tesztek hibakereséséhez állítson be töréspontot egy teszten, keresse meg a Tesztkezelőt, és válassza a Legutóbbi futtatás hibakeresésének futtatása > lehetőséget.

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

Az Azure Functions Tools a Visual Studio 2017-től kezdve elérhető 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 Toolst. A Visual Studio 2019-ben és újabb verzióiban az Azure Functions-eszközök bővítménye 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 (szükség esetén) frissítheti az Azure Functions Tools-bővítményt a Visual Studio 2017-ben.

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 az Azure Functions és a Web Jobs Tools lehetőséget.

    Verify the Functions tools version

  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 a verzió régebbi, 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-t, válassza az Azure Functions és a Web Jobs Tools lehetőséget, majd válassza a Frissítés lehetőséget.

    Update the Functions tools version

  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 elemet, majd indítsa újra a Visual Studiót.

Következő lépések

Az Azure Functions Core-eszközökkel kapcsolatos további információkért lásd: Az Azure Functions Core Tools használata.

A függvények .NET-osztálykódtárakként való fejlesztéséről további információt az Azure Functions C# fejlesztői referenciaanyagában talál. Ez a cikk példákra is hivatkozik, amelyekből megtudhatja, hogyan deklarálhatja az Azure Functions által támogatott különböző típusú kötéseket attribútumokkal.