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 áttekintését.

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

Ez a cikk részletes információkat nyújt arról, 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.

A cikk izolált munkavállaló modell verzióját olvassa. A cikk tetején kiválaszthatja az előnyben részesített modellt.

A cikk folyamatközi modellverzióját olvassa. A cikk tetején kiválaszthatja az előnyben részesített modellt.

Fontos

A folyamatban lévő modell támogatása 2026. november 10-én megszűnik. Javasoljuk, hogy az alkalmazásait az izolált feldolgozói modellbe migrálja.

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 még nem rendelkezik Azure-fiókkal, első lépésként hozzon létre egy ingyenes 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éből válassza a Fájl>Új>Projekt lehetőséget.
Az Új projekt létrehozása párbeszédpanelen í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 párbeszédpanel Projektnév eleméhez adja meg a projekt nevét, majd válassza a Tovább gombot. 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.

A További információ párbeszédpanelen hajtsa végre az alábbi táblázatban felsorolt műveleteket:

Beállítás	Tevékenység	Leírás
Függvények feldolgozója	Válassza a .NET 8.0 Izolált (hosszú távú támogatás) lehetőséget.	A Visual Studio létrehoz egy függvényprojektet, amely egy izolált feldolgozófolyamatban fut. Az izolált feldolgozói folyamat a .NET és a .NET-keretrendszer olyan más verzióit is támogatja, amelyek nem nyújtanak hosszú távú támogatást (LTS). További információkért tekintse meg az Azure Functions futtatókörnyezeti verzióinak áttekintését.
Funkció	Válassza a Http-eseményindítót.	A Visual Studio létrehoz egy HTTP-kérés által aktivált függvényt.
Az Azurite használata futtatókörnyezeti tárfiókhoz (AzureWebJobsStorage)	Jelölje be ezt a jelölőnégyzetet.	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. Az HTTP-eseményindító nem használ tárolási fiók kapcsolati sztringet. Minden más eseményindítótípushoz érvényes tárfiók-kapcsolati sztring szükséges.
Engedélyszint	Válassza a Névtelen lehetőséget.	Ha ezt az engedélyezési beállítást használja, bármely ügyfél kulcs megadása nélkül aktiválhatja a létrehozott függvényt. Ez a konfiguráció megkönnyíti az új függvény tesztelését. További információ: Engedélyezési szint.

Beállítás	Tevékenység	Leírás
Függvények feldolgozója	Válassza a .NET 8.0 Folyamatban (hosszú távú támogatás) lehetőséget.	A Visual Studio létrehoz egy folyamatban futó függvényprojektet a 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.
Funkció	Válassza a Http-eseményindítót.	A Visual Studio létrehoz egy HTTP-kérés által aktivált függvényt.
Az Azurite használata futtatókörnyezeti tárfiókhoz (AzureWebJobsStorage)	Jelölje be ezt a jelölőnégyzetet.	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. Az HTTP-eseményindító nem használ tárolási fiók kapcsolati sztringet. Minden más eseményindítótípushoz érvényes tárfiók-kapcsolati sztring szükséges.
Engedélyszint	Válassza a Névtelen lehetőséget	Ha ezt az engedélyezési beállítást használja, bármely ügyfél kulcs megadása nélkül aktiválhatja a létrehozott függvényt. Ez a konfiguráció megkönnyíti az új függvény tesztelését. További információ: Engedélyezési szint.

Győződjön meg arról, hogy az engedélyezési szintet névtelenre állítja. Ha kiválasztja a függvény alapértelmezett szintjét, a függvénykulcsot be kell mutatnia 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.

A Functions-projekt létrehozása után a projektsablon létrehoz egy C#-projektet, telepíti a és Microsoft.Azure.Functions.Worker a Microsoft.Azure.Functions.Worker.Sdk NuGet-csomagokat, és beállítja a cél keretrendszert.

A 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: Ez a fájl 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: Ez a fájl fenntartja a függvények helyi futtatásakor használt beállításokat. Ezek a beállítások nem használhatók, amikor az alkalmazás az Azure-ban fut. További információ: Az alkalmazásbeállítások helyi használata.

Fontos

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

További információ: Projektstruktúra az izolált feldolgozói útmutatóban.

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

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

Amikor a függvényalkalmazás az Azure-ban fut, a függvények által megkövetelt beállítások titkosítva lesznek tárolva 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 alocal.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 nincsenek 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ő tárfiókot használ. A fejlesztés során használhat érvényes Tárfiókot ehhez a belső fiókhoz, vagy használhatja az Azurite emulátort.

A HTTP és a webhookok kivételével minden triggertípushoz meg kell adnia a kulcs értékét a Values.AzureWebJobsStoragelocal.settings.json fájlban:

Storage-fiók esetén állítsa be a tárfiók kapcsolati láncának értékét.
Az emulátornál állítsa az értéket a következőre UseDevelopmentStorage=true: .

Ha az emulátort használja, az üzembe helyezés előtt módosítsa ezt a beállítást egy tényleges tárfiók-kapcsolati sztringre. További információ: Local Storage Emulator.

A tárfiók kapcsolati sztringjének beállításához hajtsa végre a következő lépéseket:

Jelentkezzen be az Azure Portalra, majd nyissa meg a tárfiókot.
Válassza a Biztonság + hálózatkezelési>hozzáférési kulcsok lehetőséget. Az kulcs1 alatt másolja ki a kapcsolati karakterlánc értékét.
Nyissa meg a local.settings.json fájlt a Visual Studio-projektben. Állítsa be a AzureWebJobsStorage kulcs értékét a másolt kapcsolat stringre.
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ények á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 >lehetőséget.
Az Új elem hozzáadása párbeszédpanelen válassza az Azure-függvény, majd a Hozzáadás lehetőséget.
Válasszon ki egy eseményindítót, majd adja meg a szükséges kötési tulajdonságokat. Ha kiválaszt egy Storage-szolgáltatás eseményindítót, és konfigurálni szeretné a kapcsolatot, jelölje be az eseményindító kapcsolat konfigurálásához szükséges jelölőnégyzetet. Az alábbi példa a Queue Storage-eseményindító függvény létrehozásának beállításait mutatja be.
Válassza a Hozzáadás lehetőséget. Ha az előző lépésben bejelöli a tárkapcsolat konfigurálására szolgáló jelölőnégyzetet, megjelenik a Csatlakozás a függőséghez lap. Válasszon ki egy Azurite Storage-emulátort vagy Azure Storage-t, majd válassza a Tovább gombot.
- Ha kiválaszt egy Azurite Storage emulátort, megjelenik a Connect to Storage Azurite emulator oldal. Hajtsa végre a következő lépéseket:
  1. Válassza a Következőlehetőséget.
  2. A Módosítások összegzése lapon válassza a Befejezés lehetőséget. A Visual Studio konfigurálja a függőséget, és létrehozza az eseményindító osztályt.
- Ha az Azure Storage-t választja, megjelenik a Csatlakozás az Azure Storage-hoz lap. Hajtsa végre a következő lépéseket:
  1. Válasszon ki egy tárfiókot, majd válassza a Tovább gombot. A Visual Studio megpróbál csatlakozni az Azure-fiókjához, és lekérni egy végpontot.
  2. Válassza a Következőlehetőséget.
  3. A Módosítások összegzése lapon válassza a Befejezés lehetőséget. A Visual Studio konfigurálja a függőséget, és létrehozza az eseményindító osztályt.
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 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:

A Run() metódus az Function-gal/-gel van társítva. 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: {messageText}", message.MessageText);
    }
}

Egy statikus Run() metódusra a FunctionName jellemző. 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ő kódban az első paraméter QueueTrigger egy attribútumot alkalmaz, amely egy Queue Storage-eseményindító függvényt jelez. Az üzenetsor neve és a kapcsolati sztring beállításának neve paraméterként lesz átadva az QueueTrigger attribútumnak. Az osztályodban:

Az üzenetsornév paraméternek meg kell egyeznie az eseményindító létrehozásához használt üzenetsor nevével, például myqueue-items.
A kapcsolati sztring beállításának meg kell egyeznie az eseményindító létrehozásához használt korábbi lépésben használt névvel, például QueueStorage.

További információkért tekintse meg az Azure Functions Azure Queue Storage-eseményindítóját.

Az előző 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ó: Azure Functions-eseményindítók és kötések.

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. Ha kötéseket szeretne hozzáadni egy függvényhez, hajtsa végre a következő lépéseket:

Győződjön meg arról, hogy a projektet helyi fejlesztésre konfigurálja.
Adja hozzá a megfelelő NuGet-bővítménycsomagot minden egyes kötéshez. A kötésspecifikus NuGet-csomagkövetelmények tekintetében tekintse meg a kötés referencia cikkét. Az Azure Event Hubs-eseményindító csomagkövetelményeit például az Azure Event Hubs eseményindítója és az Azure Functions kötései című témakörben találhatja meg.
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 kódban cserélje le <BINDING_TYPE> a kötéskiterjesztés konkrét nevére, és cserélje le <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 kódban egy üzenetsor aktiválja a függvényt Run . A kimeneti kötés ezután létrehoz egy új üzenetsort 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 helyezi. 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. A forgatókönyv teljesebb példáiért lásd: Függvények csatlakoztatása az Azure Storage-hoz a Visual Studióval.

Függvények lokális lefuttatása

Az Azure Functions Core Tools használatával függvényprojekteket futtathat a helyi fejlesztőszámítógépen. Amikor egy Functions-projekt hibakereséséhez az F5 lehetőséget választja, 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ó: Azure Functions helyi fejlesztése a Core Tools használatával. 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.

Fontos

A Core Tools 4.0.6517-es verziójától kezdve a folyamatban lévő modellprojekteknek a 4.5.0-s vagy újabb Microsoft.NET.Sdk.Functionsverziójára kell hivatkoznia. Ha egy korábbi verziót használ, a func start parancs hibát okoz.

Ha hibakeresési módban szeretné elindítani a függvényt a Visual Studióban, hajtsa végre a következő lépéseket:

Válassza az F5 lehetőséget. Ha a rendszer kéri, fogadja el a Visual Studio kérését az Azure Functions Core Tools letöltésére és telepítésére. Előfordulhat, hogy tűzfalkivételt is be kell kapcsolnia, hogy az eszközök kezelni tudják a HTTP-kéréseket.
A projekt futtatásakor ugyanúgy tesztelje a kódot, mint egy üzembe helyezett függvényt.

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 Studiót használó részletesebb tesztelési forgatókönyvért tekintse meg a jelen cikk későbbi, Tesztelési függvények című szakaszát.

Közzététel az Azure platformon

Amikor közzéteszi a Functions-projektet az Azure-ban, a Visual Studio zip-telepítéssel telepíti a projektfájlokat. Ha lehetséges, válassza a Futtatás csomagfájlból 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 a Functions platformon a Web Deploy (msdeploy) használatával.

A következő 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, majd válassza a Közzététel lehetőséget.
A Közzététel lapon végezze el a következő beállításokat:
- A Cél területen válassza az Azure-t, majd a Tovább lehetőséget.
- Adott célon válassza az Azure-függvényalkalmazást, majd a Tovább gombot.
- A Functions-példányon válassza az Új 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	A névnek egyedileg kell azonosítania az új függvényalkalmazást. Fogadja el a javasolt nevet, vagy írjon be egy új nevet. A következő karakterek érvényesek: `a-z`, `0-9`és `-`.
Előfizetés neve	Az előfizetés neve	A függvényalkalmazás egy Azure-előfizetésben jön létre. Fogadja el az alapértelmezett előfizetést, vagy válasszon másikat a listából.
Erőforráscsoport	Az erőforráscsoport neve	A függvényalkalmazás egy erőforráscsoportban jön létre. Új erőforráscsoport létrehozásához válassza az Új lehetőséget. A listából kiválaszthat egy meglévő erőforráscsoportot is.
Csomag típusa	Rugalmas felhasználás	Ha egy Flex Consumption-csomagban futó függvényalkalmazásban teszi közzé a projektet, előfordulhat, hogy csak a függvényalkalmazás végrehajtásáért fizet. Más üzemeltetési tervek magasabb költségekkel járnak. FONTOS: Flex Consumption-csomag létrehozásakor először ki kell választania az App Service-csomagot, majd újra ki kell jelölnie a Flex Consumption-t a párbeszédpanellel kapcsolatos probléma elhárításához.
Operációs rendszer	Linux	A Flex Consumption csomaghoz jelenleg Linux szükséges.
Helyen	Az app service helye	Válasszon ki egy helyet egy , a Flex Consumption-csomag által támogatott Azure-régióban. Ha nem támogatott régió van kijelölve, a Létrehozás gomb szürkítve jelenik meg.
Példány memóriamérete	2048	Azoknak a virtuálisgép-példányoknak a memóriamérete , amelyekben az alkalmazás fut, egyedi a Flex Consumption csomagban.
Azure Storage	Általános célú tárfiók	A Functions-futtatókörnyezethez storage-fiók szükséges. Általános célú tárfiók konfigurálásához válassza az Új lehetőséget. Használhat olyan meglévő fiókot is, amely megfelel a tárfiók követelményeinek.
Application Insights	Application Insights-példány	Kapcsolja be az Application 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 a Függvényalkalmazás új létrehozása párbeszédpanelről. A név, előfizetés, erőforráscsoport, csomag és egyéb beállítások mezői ki vannak töltve.

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ó.
Válassza ki a Befejezésopciót. Megjelenik a Közzétételi profil létrehozási folyamat ablaka. A profil létrehozásakor válassza a Bezárás lehetőséget.
A közzétételi profillapon válassza a Közzététel lehetőséget a projektfájlokat tartalmazó csomag üzembe helyezéséhez az azure-beli új függvényalkalmazásban.

Ha az üzembe helyezés befejeződött, az Azure-beli függvényalkalmazás gyökér URL-címe megjelenik a közzétételi profil oldalán.
A közzétételi profil oldalán nyissa meg az Üzemeltetés szakaszt. Jelölje ki a három pontot (...), majd válassza ki a Megnyitás az Azure-portálon lehetőséget. Megnyílik az új Azure alkalmazás erőforrás az Azure portálon.

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

A Visual Studio nem tölti fel automatikusan az alkalmazásbeállításokat a projekt közzétételekor. Ha beállításokat ad hozzá a local.settings.json fájlhoz, azokat is hozzá kell adnia az Azure-beli 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 az, ha a Visual Studióban kezeli őket. A közzétételi profil oldalán nyissa meg az Üzemeltetés szakaszt. Jelölje ki a három pontot (...), majd válassza az Azure App Service-beállítások kezelése lehetőséget.

A kijelöléskor megnyílik az Alkalmazásbeállítások párbeszédpanel a függvényalkalmazáshoz. Ezen a párbeszédpanelen alkalmazásbeállításokat adhat hozzá, vagy módosíthatja a meglévőket.

Képernyőkép az Alkalmazásbeállítások párbeszédpanelről, amely a különböző beállítások helyi és távoli értékeit, valamint az értékek hozzáadására és szerkesztésére szolgáló vezérlőket jeleníti meg.

Minden beállításnál a Helyi érték az local.settings.json fájlban lévő érték, a Távoli érték pedig az Azure-beli függvényalkalmazás értéke.

Alkalmazásbeállítás létrehozásához válassza a Beállítás hozzáadása lehetőséget.
Ha a Helyi mezőről a Távoli mezőre szeretne másolni egy beállításértéket, válassza az Érték beszúrása a Helyi mezőből lehetőséget.

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. Ennek eredményeképpen, ha egy helyi Functions-projektet klónozott a forrásvezérlőből, a projekt nem rendelkezik local.settings.json fájllal. 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:

Használja az Azure Portalt.
Használja a --publish-local-settings közzétételi lehetőséget az Azure Functions Core Toolsban.
Használja az Azure CLI-t.

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. A távoli hibakeresést is be kell kapcsolnia az Azure-beli függvényalkalmazásban.

Ez a szakasz feltételezi, hogy a függvényalkalmazás hibakeresési konfigurációja közzé van téve.

Távoli hibakeresési szempontok

Éles szolgáltatásban nem ajánlott a távoli hibakeresés.
A távoli hibakeresés használatához prémium vagy App Service-csomagban kell üzemeltetnie a függvényalkalmazást.
A távoli hibakeresés jelenleg csak akkor támogatott, ha a C# alkalmazást Windows rendszeren futtatja.
Ha be van kapcsolva a Just My Code funkció a Visual Studióban, kapcsolja ki. Útmutatásért lásd: Just My Code engedélyezése vagy letiltása.
Távoli hibakeresés esetén kerülje a hosszú várakozást a töréspontoknál. Ha egy folyamat néhány percnél hosszabb ideig leáll, az Azure nem válaszoló folyamatként kezeli, és leállítja.
A hibakeresés során 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ásról további információt a Díjszabás kalkulátorában talál.
A távoli hibakeresés 48 óra után automatikusan ki van kapcsolva a függvényalkalmazásban. Ezután vissza kell kapcsolnia a távoli hibakeresést.

A hibakereső csatolása

Izolált feldolgozófolyamat-alkalmazás hibakeresésekor a távoli hibakeresőt jelenleg egy külön .NET-folyamathoz kell csatolnia. Számos egyéb konfigurációs lépésre is szükség van.

Ha távoli hibakeresőt szeretne csatolni a Functions-gazdagéptől eltérő folyamatban futó függvényalkalmazáshoz, hajtsa végre a következő lépéseket:

A közzétételi profil oldalán nyissa meg az Üzemeltetés szakaszt. Válassza az alábbi pontokat (...), majd válassza a Hibakereső indítása lehetőséget.

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

Feljegyzés

Mivel a távoli hibakereső nem tud csatlakozni a gazdagép folyamatához, hibaüzenet jelenhet meg. A helyi hibakereső mindenesetre nem tud hozzáférni a töréspontokhoz, és nem biztosít módot a változók vizsgálatára vagy a kód végiglépésére.
A Visual Studio Hibakeresés menüjében válassza a Csatolás a folyamathoz lehetőséget.
A Folyamat csatolása párbeszédpanelen hajtsa végre a következő lépéseket:
1. A Kapcsolat típusa mellett válassza a Microsoft Azure App Services lehetőséget.
2. A Kapcsolati cél mellett válassza a Keresés lehetőséget.
Az Azure Attach to Process párbeszédpanelen keresse meg és válassza ki a függvényalkalmazást, majd kattintson az OK gombra.
Ha a rendszer kéri, engedélyezze a Visual Studio elérését a helyi tűzfalon keresztül.
A Folyamat csatolása párbeszédpanelen válassza az Összes felhasználó folyamatainak megjelenítése lehetőséget. Válassza adotnet.exe, majd a Csatolás lehetőséget.

Amikor a művelet befejeződik, egy elkülönített feldolgozói folyamatban futó C# osztálykönyvtár kódhoz kapcsolódsz. Ezen a ponton a függvényalkalmazást a szokásos módon hibakeresésre használhatja.

Ha távoli hibakeresőt szeretne csatolni egy, a Functions-gazdagéppel folyamatban lévő függvényalkalmazáshoz, hajtsa végre az alábbi lépéseket.

A közzétételi profil oldalán nyissa meg az Üzemeltetés szakaszt. Válassza az alábbi pontokat (...), majd válassza a Hibakereső indítása lehetőséget.

A Visual Studio csatlakozik a függvényalkalmazáshoz, és bekapcsolja a távoli hibakeresést, ha még nincs bekapcsolva. Emellett megkeresi és csatolja a hibakeresőt az alkalmazás gazdafolyamatához. Ezen a ponton a függvényalkalmazást a szokásos módon hibakeresésre használhatja.

A hibakeresés befejezésekor ki kell kapcsolnia a távoli hibakeresést.

Távoli hibakeresés kikapcsolása

Miután befejezte a kód távoli hibakeresését, ki kell kapcsolnia a távoli hibakeresést az Azure Portalon. A távoli hibakeresés 48 óra elteltével automatikusan ki van kapcsolva, ha elfelejtené.

A közzétételi profil oldalán nyissa meg az Üzemeltetés szakaszt. Jelölje ki a három pontot (...), majd válassza ki a Megnyitás az Azure-portálon lehetőséget. Megnyílik az Azure Portal azon függvényalkalmazás számára, amelybe a projekt telepítve van.
A függvényalkalmazásban válassza a Beállítások>konfigurációja lehetőséget, majd lépjen az Általános beállítások lapra. A Távoli hibakeresés mellett válassza a Ki elemet. 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. Az Azure Portal ugyanezzel a fülével bekapcsolhatja a távoli hibakeresést a Visual Studión kívül.

Monitorozási funkciók

A függvények figyelésének ajánlott módja a függvényalkalmazás és az Application Insights integrálása. Ezt az integrációt be kell kapcsolnia, amikor a Visual Studio-beli telepítés során létrehozza a függvényalkalmazását.

Ha az integráció valamilyen okból nem van beállítva a közzététel során, akkor is be kell kapcsolnia az Application Insights-integrációt a függvényalkalmazáshoz az Azure-ban.

További információ az Application Insights monitorozáshoz való használatáról: Végrehajtások monitorozása az Azure Functionsben.

Tesztfüggvények

Ez a szakasz azt ismerteti, hogyan hozhat létre egy C# folyamatközi modellprojektet, amelyet a .NET-hez készült nyílt forráskódú egységtesztelési eszköz, az xUnit használatával tesztelhet.

1. lépés: Beállítás

Kövesse az alábbi lépéseket a környezet konfigurálásához, beleértve az alkalmazásprojektet és a tesztek támogatásához szükséges függvényeket:

A Visual Studióban hozzon létre egy Functions nevű Azure Functions-projektet.
HTTP-függvény létrehozása a sablonból:
1. A Megoldáskezelőben kattintson a jobb gombbal a Functions-projektre, majd válassza azÚj Azure-függvény> lehetőséget.
2. Az Új elem hozzáadása párbeszédpanelen válassza az Azure-függvény, majd a Hozzáadás lehetőséget.
3. Válassza a Http-eseményindítót, majd a Hozzáadás lehetőséget.
4. Nevezze át az új MyHttpTrigger osztályt.
Időzítő függvény létrehozása a sablonból
1. A Megoldáskezelőben kattintson a jobb gombbal a Functions-projektre, majd válassza azÚj Azure-függvény> lehetőséget.
2. Az Új elem hozzáadása párbeszédpanelen válassza az Azure-függvény, majd a Hozzáadás lehetőséget.
3. Válassza az Időzítő eseményindítót, majd a Hozzáadás lehetőséget.
4. Nevezze át az új MyTimerTrigger osztályt.
Hozzon létre egy xUnit-tesztalkalmazást a megoldásban:
1. A Megoldáskezelőben kattintson a jobb gombbal a Functions-projektet tartalmazó megoldásra, majd válassza azÚj projekt> lehetőséget.
2. Válassza az xUnit Test Project sablont , majd válassza a Tovább lehetőséget.
3. Nevezze el a projekt Functions.Tests nevét.
Távolítsa el az alapértelmezett tesztfájlokat a Functions.Tests projektből.
A NuGet használatával adjon hozzá egy hivatkozást a tesztalkalmazásból a Microsoft.AspNetCore.Mvc fájlhoz. Használhatja a Package Manager-konzolt, vagy a következő lépéseket teheti:
1. A Megoldáskezelőben kattintson a jobb gombbal a Functions.Tests projektre, majd válassza a NuGet-csomagok kezelése lehetőséget.
2. Keresse meg és telepítse a Microsoft.AspNetCore.Mvc fájlt.
A Functions.Tests alkalmazásban adjon hozzá egy hivatkozást a Functions alkalmazáshoz:
1. A Megoldáskezelőben kattintson a jobb gombbal a Functions.Tests projektre, majd válassza aProjekthivatkozás>.
2. Válassza ki a Functions-projektet , majd kattintson az OK gombra.

2. lépés: Tesztosztályok létrehozása

Ebben a szakaszban az automatikus tesztek futtatásához használt osztályokat hozza létre.

Minden függvény egy implementációt ILogger vesz fel az üzenetnaplózás kezeléséhez. Egyes tesztekben a rendszer nem naplózza az üzeneteket, vagy nem számít, hogyan implementálják a naplózást. A többi tesztnek ki kell értékelnie a naplózott üzeneteket annak megállapításához, hogy egy tesztnek sikeresnek kell-e lennie.

Hozzon létre egy osztályt a Functions.Tests projektben, NullScope és adja hozzá a következő kódot. Ez az osztály egy makett hatókört biztosít. Egy későbbi lépésben létrehoz egy implementációt ILogger , amely ezt a hatókört használja.
```
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 és adja hozzá a következő kódot. Ez az osztály a tesztelés során kiértékelendő üzenetek belső listáját tartalmazza. A szükséges ILogger interfész megvalósításához az osztály a NullScope osztály modellhatókörét használja. A tesztesetek átadják a modell hatókörét az ListLogger osztálynak.
```
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 a ILogger interfész által meghatározott módon.
- BeginScope: A tartományok kontextust adnak a naplózáshoz. Ebben az esetben a teszt a NullScope osztály statikus példányára mutat, hogy lehetővé tegye a teszt működését.
- IsEnabled: Meg van adva egy false alapértelmezett érték.
- Log: Ez a metódus a megadott formatter függvény használatával formázza az üzenetet. A metódus ezután hozzáadja az eredményként kapott szöveget a Logs gyűjteményhez.
A Logs gyűjtemény a List<string> egy példánya, és a konstruktorban van inicializálva.
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 adja meg.

Hozzon létre egy osztályt a Functions.Tests projektben, TestFactory é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", "Bernardo" },
                new object[] { "name", "Ananya" },
                new object[] { "name", "Vlad" }

            };
        }

        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:

Data: Ez a tulajdonság egy IEnumerable mintaadat-gyűjteményt ad vissza. A kulcs-érték párok a lekérdezési sztringbe átadott értékeket jelölik.
CreateDictionary: Ez a metódus argumentumként elfogad egy kulcs-érték párot. Visszaad egy új példányt a Dictionary-ból, amelyet egy QueryCollection példány létrehozására használnak a lekérdezési sztring értékeinek képviseletére.
CreateHttpRequest: Ez a metódus létrehoz egy HTTP-kérést, amely a megadott lekérdezési sztringparaméterekkel inicializálva van.
CreateLogger: Ez a módszer egy, a teszteléshez használt ILogger implementációt ad vissza. A ILogger megvalósítás a megadott naplózási típustól függ. Ha meg van adva egy listatípus, a ListLogger példány nyomon követi a naplózott üzeneteket, amelyek a tesztekben kiértékelhetők.

Hozzon létre egy osztályt a Functions.Tests projektben, FunctionsTests é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", "Bernardo");
            var response = (OkObjectResult)await MyHttpTrigger.Run(request, logger);
            Assert.Equal("Hello, Bernardo. 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);
        }
    }
}

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

Http_trigger_should_return_known_string: Ez a teszt a lekérdezési sztring értékével name=Bernardo hoz létre kérést egy HTTP-függvényhez. Ez a teszt 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 ListLogger példányt, és átadja egy időzítőfüggvénynek. A függvény futtatása után a rendszer ellenőrzi, hogy a várt üzenet jelen van-e.

Ha hozzá szeretne férni a tesztek alkalmazásbeállításaihoz, egy implementációt szimulált környezeti változó értékekkel szúrhat beIConfiguration a függvénybe.

3. lépés: Tesztek futtatása

A tesztek Visual Studióban való futtatásához válassza aTesztböngésző>. A Test Explorerben válassza azÖsszes teszt futtatása> nézetben lehetőséget.

Képernyőkép a Visual Studióról. A Test Explorer azt mutatja, hogy öt teszt sikeres volt. A Megoldáskezelőben a Functions és a Functions.Test projektek láthatók.

4. lépés: Hibakeresési tesztek

A tesztek hibakereséséhez állítson be töréspontot egy teszten. A Test Explorerben válassza aLegutóbbi futtatás hibakeresésének> lehetőséget.

Az Azure Functions helyi fejlesztése a Core Tools használatával

C# folyamatközi modell útmutatója

C# izolált feldolgozómodell útmutatója

Visszajelzés

Hasznosnak találta ezt az oldalt?

Last updated on 2025-09-23