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

Cikk
03/05/2024

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.

Ha azonnal hozzá szeretne kezdeni, fontolja meg a Visual Studio Functions rövid útmutatójának elvégzését.

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 C#-osztálytárfüggvények fejlesztéséhez két modell létezik: az izolált feldolgozói modell és a folyamatban lévő modell.

Ebben a cikkben az izolált feldolgozómodell-verziót olvassa. A cikk tetején kiválaszthatja az előnyben részesített modellt.

Ebben a cikkben a folyamatban lévő modell verzióját olvassa. A cikk tetején kiválaszthatja az előnyben részesített modellt.

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

Visual Studio 2022, beleértve az Azure fejlesztési számítási feladatait is.
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, első lépésként 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.

A Visual Studio menüjében válassza az Új>projekt fájlja>lehetőséget.
Ú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.
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.

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 Izolált	Ez az érték létrehoz egy függvényprojektet, amely egy izolált feldolgozófolyamatban fut. Az izolált feldolgozói folyamat támogatja a .NET egyéb nem LTS-verzióját, és .NET-keretrendszer is. 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ó: Engedélyezési szint.

Képernyőkép az Azure Functions projektbeállításairól

Beállítás	Érték	Leírás
.NET-verzió	.NET 6	Ez az érték létrehoz egy folyamatban futó függvényprojektet az Azure Functions-futtatókörnyezet 4.x verziójával. 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ó: Engedélyezési szint.

Képernyőkép az Azure Functions projektbeállításairól

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.

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 és Microsoft.Azure.Functions.Worker.Sdk NuGet-csomagokatMicrosoft.Azure.Functions.Worker, és beállítja a cél keretrendszert.

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: A függvények helyi futtatásakor használt beállításokat tartja karban. 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ó: Projektstruktúra az Izolált feldolgozók útmutatójában.

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 ezeket a beállításokat a rendszer ehelyett hozzáadja a Values gyűjteményhez 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.

Values A projekt local.settings.json fájljában található gyűjtemény elemei a függvényalkalmazás azure-beli alkalmazásbeállításaiban lévő elemek tükrözésére szolgálnak.

A Visual Studio nem tölti fel automatikusan a beállításokat local.settings.json 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 AzureWebJobsStorage UseDevelopmentStorage=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:

Az Azure Portalon lépjen a tárfiókra.
Másolja az 1. kulcs kapcsolati sztringjét az Access billentyűk lap Biztonság + hálózatkezelés csoportjába.
A projektben nyissa meg a local.settings.json fájlt, és állítsa a AzureWebJobsStorage kulcs értékét a másolt kapcsolati sztring.
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.

A Megoldáskezelő kattintson a jobb gombbal a projektcsomópontra, és válassza az Új Azure-függvény hozzáadása>lehetőséget.
Adja meg az osztály nevét, majd válassza a Hozzáadás lehetőséget.
Válassza ki az eseményindítót, adja meg a szükséges kötési tulajdonságokat, 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.

Azure Storage-szolgáltatás-eseményindító esetén jelölje be a Kapcsolat konfigurálása jelölőnégyzetet, és a rendszer kérni fogja, hogy válasszon az Azurite Storage emulátor használata vagy egy kiépített Azure-tárfiókra való hivatkozás között. Válassza a Tovább lehetőséget, és ha tárfiókot választ, a Visual Studio megpróbál csatlakozni az Azure-fiókjához, és lekérni a kapcsolati sztring. Válassza a Save kapcsolati sztring value in Local user secrets file, majd a Finish (Befejezés) lehetőséget az eseményindító osztály létrehozásához.

Ez az eseményindító-példa egy alkalmazásbeállítást használ a tárkapcsolathoz egy nevesített QueueStoragekulccsal. Ez a local.settings.json fájlban tárolt kulcs vagy az Azurite emulátorra vagy egy Azure Storage-fiókra hivatkozik.

Vizsgálja meg az újonnan hozzáadott osztályt. A következő C#-osztály például egy alapszintű Queue Storage-eseményindító függvényt jelöl:

Megjelenik egy statikus Run() metódus, amelynek attribútuma a Functionkövetkező: . Ez az attribútum azt jelzi, hogy a metódus a függvény belépési pontja.

using System;
using Azure.Storage.Queues.Models;
using Microsoft.Azure.Functions.Worker;
using Microsoft.Extensions.Logging;

namespace Company.Function
{
    public class QueueTriggerCSharp
    {
        private readonly ILogger<QueueTriggerCSharp> _logger;

        public QueueTriggerCSharp(ILogger<QueueTriggerCSharp> logger)
        {
            _logger = logger;
        }

        [Function(nameof(QueueTriggerCSharp))]
        public void Run([QueueTrigger("PathValue", Connection = "ConnectionValue")] QueueMessage message)
        {
            _logger.LogInformation($"C# Queue trigger function processed: {message.MessageText}");
        }
    }
}

Megjelenik egy statikus Run() metódus, amelynek attribútuma a FunctionNamekövetkező: . Ez az attribútum azt jelzi, hogy a metódus a függvény belépési pontja.

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

namespace Company.Function
{
    public class QueueTriggerCSharp
    {
        [FunctionName("QueueTriggerCSharp")]
        public void Run([QueueTrigger("PathValue", Connection = "ConnectionValue")]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:

Győződjön meg arról, hogy a projektet helyi fejlesztésre konfigurálja.
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.
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>
```
```
Install-Package Microsoft.Azure.WebJobs.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 4.0.0. Az érvényes verziók a NuGet.org egyes csomagoldalain jelennek meg.
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. A Visual Studio megkönnyíti a helyi beállítások közzétételét az Azure-ban.

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 class QueueTrigger
{
    private readonly ILogger _logger;

    public QueueTrigger(ILoggerFactory loggerFactory)
    {
        _logger = loggerFactory.CreateLogger<QueueTrigger>();
    }

    [Function("CopyQueueMessage")]
    [QueueOutput("myqueue-items-destination", Connection = "QueueStorage")]
    public string Run([QueueTrigger("myqueue-items-source", Connection = "QueueStorage")] string myQueueItem)
    {
        _logger.LogInformation($"C# Queue trigger function processed: {myQueueItem}");
        return myQueueItem;
    }
}

Az QueueOutput attribútum határozza meg a metódus kötését. Több kimeneti kötés esetén ehelyett ezt az attribútumot a visszaadott objektum sztringtulajdonságára helyezné. További információ: Több kimeneti kötés.

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

A Queue paraméter attribútuma out határozza meg a kimeneti kötést.

A Queue Storage-hoz való kapcsolat a beállításból származik QueueStorage . 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 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ó: 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:

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.
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 közzéteszi a függvényprojektet az Azure-ban, a Visual Studio zip-telepítéssel telepíti a projektfájlokat. Ha lehetséges, válassza a Futtató csomag lehetőséget is, hogy a projekt az üzembe helyezési (.zip) csomagban fusson. További információ: Függvények futtatása csomagfájlból az Azure-ban.

Ne helyezzen üzembe az Azure Functionsben a Web Deploy (msdeploy) használatával.

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

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-t, majd a Tovább lehetőséget.
Adott célon válassza az Azure Function App (Windows) lehetőséget. Létrejön egy Windows rendszeren futó függvényalkalmazás. Válassza a Tovább lehetőséget.
A Functions-példányon válassza az Új Azure-függvény létrehozása lehetőséget.

Hozzon létre egy új példányt az alábbi 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 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. Új erőforráscsoport létrehozásához válassza az Új lehetőséget. A legördülő listából egy meglévő erőforráscsoportot is használhat.
Csomag típusa	Felhasználás	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.
Helyen	Az app service helye	Válasszon ki egy helyet egy Önhöz közeli Azure-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. Azt is választhatja, hogy egy meglévő fiókot használ, amely megfelel a tárfiók követelményeinek.
Application Insights	Application Insights-példány	Engedélyeznie kell Azure-alkalmazás Insights-integrációt a függvényalkalmazáshoz. Az Új lehetőséget választva új példányt hozhat létre egy új vagy egy meglévő Log Analytics-munkaterületen. Egy meglévő példányt is használhat.

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

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ó.
A Functions-példányon győződjön meg arról, hogy a Futtatás csomagfájlból jelölőnégyzet be van jelölve. A függvényalkalmazás üzembe helyezése a Zip Deploy funkció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 a jobb teljesítmény érdekében.
Válassza a Befejezés lehetőséget, majd a Közzététel panelen 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ésekor az Azure-beli függvényalkalmazás gyökér URL-címe megjelenik a Közzététel lapon.
A Közzététel lap Üzemeltetés szakaszában válassza a Megnyitás az Azure Portalon lehetőséget. Megnyílik az új Azure-függvényalkalmazás az Azure Portalon.

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

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

Feljegyzé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ö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ó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:

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.

Figyelemfelhívá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.
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.

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

Feljegyzé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.
Másolja a Webhely URL-címét a Visual Studióba a Közzététel lapon.
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 kapcsolati 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.
Ha a rendszer kéri, engedélyezze a Visual Studio elérését a helyi tűzfalon keresztül.
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.
Ellenőrizze az összes felhasználó folyamatának megjelenítése lehetőséget, majd válassza a dotnet.exe, 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ő csatolása folyamatban lévő függvényalkalmazáshoz a Functions-gazdagéppel:

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

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

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.
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 beállítások lehetőséget, állítsa ki a távoli hibakeresést, és 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. 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ére ajánlott a függvényalkalmazás integrálása a Azure-alkalmazás Insights szolgáltatással. Ezt az integrációt engedélyeznie kell, amikor a Függvényalkalmazást a Visual Studio közzététele során hozza létre.

Ha valamilyen okból az integráció nem történt meg a közzététel során, akkor is engedélyeznie kell az Application Insights-integrációt a függvényalkalmazáshoz az Azure-ban.

Az Application Insights 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 egy C# folyamatközi modellprojektet, amelyet tesztelhet az xUnittal.

Az Azure Functions tesztelése C# használatával a Visual Studióban

1. Beállítás

Az alábbi lépésekkel konfigurálhatja a környezetet, beleértve az alkalmazásprojektet és a függvényeket, amelyek a tesztek támogatásához szükségesek:

Új Functions-alkalmazás létrehozása és a Functions elnevezése
Hozzon létre egy HTTP-függvényt a sablonból, és nevezze el MyHttpTriggernek.
Hozzon létre egy időzítőfüggvényt a sablonból , és nevezze el MyTimerTriggernek.
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.
A NuGet használatával referenciát adhat hozzá a tesztalkalmazásból a Microsoft.AspNetCore.Mvc fájlhoz
Hivatkozzon a Functions alkalmazásra a Functions.Tests alkalmazásból.

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

2. Tesztosztályok létrehozása

Minden függvény egy-egy példányt ILogger 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.

Hozzon létre egy 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 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, és adja hozzá 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() { }
    }
}

Hozzon létre egy osztályt a Functions.Tests projektben ListLogger.cs, és adja hozzá 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.

Hozzon létre egy LoggerTypes.cs nevű kódfájlt a Functions.Tests projektben, és adja hozzá 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.

Hozzon létre egy osztályt a Functions.Tests projektben TestFactory.cs, és adja hozzá 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.

Hozzon létre egy osztályt a Functions.Tests projektben FunctionsTests.cs néven, és adja hozzá 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, egy olyan példányt IConfiguration szúrhat be a függvénybe, amely ki van használva a környezeti változók értékeivel.

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